boc
0.4.1
olifanton/interop en su lugar. Puerto PHP de la biblioteca tonweb-boc JS
composer require olifanton/boc Instale el paquete olifanton/boc a través del compositor e incluya el script de AutOload:
<?php declare (strict_types= 1 );
require __DIR__ . " /vendor/autoload.php " ;
use Olifanton Boc BitString ;
use Olifanton Boc Cell ;
// Now you can use BoC classesOlifantonBocBitString BitString es una clase que le permite manipular datos binarios. BitString está en el corazón de la representación de PHP de las células TVM. BitString está optimizada para la memoria para almacenar datos binarios. Internamente, BitString utiliza la implementación de Uint8Array proporcionada por el paquete ajf/typed-arrays y se utiliza como tipo base para transferir datos binarios entre partes de las bibliotecas Olifanton.
La instancia de Bitstring se crea con una longitud estrictamente fija. write% (WriteBit, WriteUint, ...) Métodos Mueva el cursor interno. Si intenta escribir un valor que exceda la longitud de los bits libres, se lanzará la excepción BitStringException .
/**
* @param int $length
*/
public function __construct( int $ length )Parámetros:
$length - Longitud de Uint8Array. Valor predeterminado para la celda TVM: 1023 (documentación) Devuelve la longitud de bits de bits no utilizados.
Devuelve los bits usados longitud de bitstring.
Devuelve la longitud de bytes usada de bitstring.
/**
* @param int $n Position
*/
public function get( int $ n ): bool Devuelve un valor un poco a la posición de $n
/**
* @param int $n Position
*/
public function on( int $ n ): void Establece un valor un poco en 1 en la posición $n .
/**
* @param int $n Position
*/
public function off( int $ n ): void Establece un valor de un poco a 0 en la posición $n .
/**
* @param int $n Position
*/
public function toggle( int $ n ): void Valor de bit de al revés (inverso) en la posición $n .
Devuelve el generador de bits usados.
Ejemplo:
<?php declare (strict_types= 1 );
use Olifanton Boc BitString ;
$ bs = new BitString ( 4 );
$ bs -> writeBit ( 1 );
$ bs -> writeBit ( 0 );
$ bs -> writeBit ( 1 );
$ bs -> writeBit ( 1 );
foreach ( $ bs -> iterate () as $ b ) {
echo ( int ) $ b ;
}
// Prints "1011" /**
* @param int|bool $b
*/
public function writeBit( int | bool $ b ): voidEscribe bit y aumenta el cursor interno de bitstring.
/**
* @param array<int | bool> $ba Array of bits
*/
public function writeBitArray( array $ ba ): voidEscribe una serie de bits.
Ejemplo:
<?php declare (strict_types= 1 );
use Olifanton Boc BitString ;
$ bs = new BitString ( 4 );
$ bs -> writeBitArray ([ 1 , false , 0 , true ]);
foreach ( $ bs -> iterate () as $ b ) {
echo ( int ) $ b ;
}
// Prints "1001" /**
* @param int|BrickMathBigInteger $number Unsigned integer
* @param int $bitLength Integer size (8, 16, 32, ...)
*/
public function writeUint( int | BigInteger $ number , int $ bitLength ): voidEscribe $ BitLength-bit Unsigned Integer.
/**
* @param int|BrickMathBigInteger $number Signed integer
* @param int $bitLength Integer size (8, 16, 32, ...)
*/
public function writeInt( int | BigInteger $ number , int $ bitLength ): voidEscribe $ BitLength-Bit Integer firmado.
Método de alias de writeUint() con valor de parámetro $ bitLength predefinido.
/**
* @param ajfTypedArraysUint8Array $ui8 Byte array
*/
public function writeBytes( Uint8Array $ ui8 ): voidEscriba la matriz de enteros sin firmar de 8 bits.
/**
* @param string $value
*/
public function writeString( string $ value ): voidEscribe cadena UTF-8.
/**
* @param int|BrickMathBigInteger $amount
*/
public function writeCoins( int | BigInteger $ amount ): void ;Escribe monedas en nanotoncoins. 1 tonelada === 1000000000 (10^9) nanotoncoins.
/**
* @param OlifantonUtilsAddress|null $address TON Address
*/
public function writeAddress(? Address $ address ): voidEscribe la dirección tonelada. Consulte la implementación de la dirección en el paquete Olifanton/Utils.
/**
* @param OlifantonBocBitString $anotherBitString BitString instance
*/
public function writeBitString( BitString $ anotherBitString ): voidEscribe otra bitsting a esta bitstring.
Clones esta bitstring y devuelve una nueva instancia de bitstring.
Devuelve la representación de cadena hexadecimal de BitString.
Devuelve una copia inmutable de UINT8Array interno.
Devuelve el tamaño de la bits en bits.
OlifantonBocCell Cell es una clase que implementa el concepto de células TVM en PHP. Para crear mensajes nuevos y recibidos de Blockchain, trabajará con instancias de la clase Cell.
Sin parámetros.
/**
* @param string|Uint8Array $serializedBoc Serialized BoC
* @return Cell[]
*/
public static function fromBoc( string | Uint8Array $ serializedBoc ): arrayCrea matriz de celdas de la matriz de bytes o cadena hexadecimal.
/**
* @param string|Uint8Array $serializedBoc Serialized BoC
* @param bool $isBase64 Base64-serialized flag, default false
*/
public static function oneFromBoc( string | Uint8Array $ serializedBoc , bool $ isBase64 = false ): CellObtenga una celda de raíz de la matriz de bytes o una cadena hexadecimal.
/**
* @param Cell $anotherCell Another cell
* @return Cell This Cell
*/
public function writeCell( Cell $ anotherCell ): selfEscribe otra célula a esta célula y devuelve esta célula. Método mutable.
Devuelve la profundidad máxima de las celdas infantiles.
Devuelve una instancia interna de bitstres para escribir y leer.
Devuelve el objeto similar a la matriz de las células infantiles.
Devuelve el hash SHA-256 de esta célula.
Imprime recursivamente el contenido de Cell como Fift.
/**
* @param bool $has_idx Default _true_
* @param bool $hash_crc32 Default _true_
* @param bool $has_cache_bits Default _false_
* @param int $flags Default _0_
*/
public function toBoc( bool $ has_idx = true ,
bool $ hash_crc32 = true ,
bool $ has_cache_bits = false ,
int $ flags = 0 ): Uint8ArrayCrea una matriz de byte boc.
OlifantonBocSlice Slice es el tipo de rebanadas celulares. Se puede transformar una celda en una porción, y luego los bits de datos y las referencias a otras células de la celda se pueden obtener cargándolas de la porción.
Métodos load% (loadbit, carga, ...) Mueva el cursor interno de corte. Si intenta leer un valor que excede la longitud de los bits libres, se lanzará la excepción de SliceException .
/**
* @param ajfTypedArraysUint8Array $array
* @param int $length
* @param OlifantonBocSlice[] $refs
*/
public function __construct( Uint8Array $ array , int $ length , array $ refs )Parámetros:
$array - Uint8Array de la representación de Bittring of Cell$length - Longitud de bitstring$refs - Slices de células infantiles Devuelve los bits no leídos de acuerdo con el cursor interno.
/**
* @param int $n
*/
public function get( int $ n ): bool Devuelve un valor un poco en la posición $n .
Lee un poco y mueve el cursor.
/**
* @param int $bitLength
*/
public function loadBits( int $ bitLength ): Uint8ArrayLee una matriz de bits.
/**
* @param int $bitLength
*/
public function loadUint( int $ bitLength ): BigIntegerLee Integer Unsigned.
/**
* @param int $bitLength
*/
public function loadInt( int $ bitLength ): BigIntegerLee Integer firmado.
/**
* @param int $bitLength
*/
public function loadVarUint( int $ bitLength ): BigInteger Lee una cantidad de tonelada en nanotoncoins.
Dirección de lectura.
Lee la rebanada de la célula de los niños.
composer run testMIT
