boc
0.4.1
olifanton/interop . Porta php da biblioteca JS tonweb-boc
composer require olifanton/boc Instale o pacote olifanton/boc via compositor e inclua o script automático:
<?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 é uma classe que permite manipular dados binários. BitString está no coração da representação PHP das células TVM. BitString é otimizado pela memória para armazenar dados binários. Internamente, o BitString usa a implementação do Uint8Array fornecido pelo pacote ajf/typed-arrays e é usado como tipo de base para transferir dados binários entre partes das bibliotecas Olifanton.
A instância do bitstring é criada com um comprimento estritamente fixo. write% (Writebit, WriteUint, ...) Métodos movem o cursor interno. Se você tentar escrever um valor que exceder o comprimento dos bits gratuitos, a exceção BitStringException será lançada.
/**
* @param int $length
*/
public function __construct( int $ length )Parâmetros:
$length - comprimento de uint8array. Valor padrão para a célula TVM: 1023 (documentação) Retorna os bits não utilizados comprimento do bitsstring.
Retorna os bits usados comprimento da placa de bits.
Retornos usados bytes comprimento da placa de bits.
/**
* @param int $n Position
*/
public function get( int $ n ): bool Retorna um valor de um pouco na posição $n .
/**
* @param int $n Position
*/
public function on( int $ n ): void Define um pouco de valor para 1 na posição $n .
/**
* @param int $n Position
*/
public function off( int $ n ): void Define um valor de um pouco para 0 na posição $n .
/**
* @param int $n Position
*/
public function toggle( int $ n ): void Alterne (inverso) Valor de bit na posição $n .
Retorna gerador de bits usados.
Exemplo:
<?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 ): voidEscreve bit e aumenta o cursor interno do bitstring.
/**
* @param array<int | bool> $ba Array of bits
*/
public function writeBitArray( array $ ba ): voidEscreve uma variedade de bits.
Exemplo:
<?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 ): voidEscreve $ inteiro não assinado.
/**
* @param int|BrickMathBigInteger $number Signed integer
* @param int $bitLength Integer size (8, 16, 32, ...)
*/
public function writeInt( int | BigInteger $ number , int $ bitLength ): voidGrava $ bitlength-bit assinado inteiro.
Alias do método writeUint() com valor de parâmetro predefinido $ bitLength.
/**
* @param ajfTypedArraysUint8Array $ui8 Byte array
*/
public function writeBytes( Uint8Array $ ui8 ): voidEscreva uma variedade de números inteiros de 8 bits não assinados.
/**
* @param string $value
*/
public function writeString( string $ value ): voidGrava a string utf-8.
/**
* @param int|BrickMathBigInteger $amount
*/
public function writeCoins( int | BigInteger $ amount ): void ;Escreve moedas em nanotoncons. 1 tonelada === 1000000000 (10^9) Nanotoncoins.
/**
* @param OlifantonUtilsAddress|null $address TON Address
*/
public function writeAddress(? Address $ address ): voidEscreve endereço ton. Consulte a implementação do endereço no pacote Olifanton/Utils.
/**
* @param OlifantonBocBitString $anotherBitString BitString instance
*/
public function writeBitString( BitString $ anotherBitString ): voidEscreve outra placa de bits para esta placa de bits.
Clones Esta placa de bits e retorna uma nova instância de bitstring.
Retorna a representação hexadecimal da string do bitstring.
Retorna cópia imutável do Uint8Array interno.
Retorna o tamanho da placa de bits em bits.
OlifantonBocCell Cell é uma classe que implementa o conceito de células TVM no PHP. Para criar mensagens novas e processadas do Blockchain, você trabalhará com instâncias da classe de células.
Sem parâmetros.
/**
* @param string|Uint8Array $serializedBoc Serialized BoC
* @return Cell[]
*/
public static function fromBoc( string | Uint8Array $ serializedBoc ): arrayCria uma matriz de células da matriz de bytes ou string 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 ): CellPegue uma célula raiz da matriz de bytes ou string hexadecimal.
/**
* @param Cell $anotherCell Another cell
* @return Cell This Cell
*/
public function writeCell( Cell $ anotherCell ): selfEscreve outra célula para esta célula e retorna esta célula. Método mutável.
Retorna a profundidade máxima das células crianças.
Retorna a instância interna do bitstring para escrever e ler.
Retorna objeto semelhante a uma matriz de células infantis.
Retorna o hash sha-256 desta célula.
Imprime recursivamente o conteúdo da célula como o 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 ): Uint8ArrayCria o Boc Byte Array.
OlifantonBocSlice Slice é o tipo de fatias de células. Uma célula pode ser transformada em uma fatia e, em seguida, os bits de dados e referências a outras células da célula podem ser obtidos carregando -os da fatia.
load% (LoadBit, LoadUint, ...) Métodos move o cursor interno da fatia. Se você tentar ler um valor que exceder o comprimento dos bits gratuitos, a exceção SliceException será lançada.
/**
* @param ajfTypedArraysUint8Array $array
* @param int $length
* @param OlifantonBocSlice[] $refs
*/
public function __construct( Uint8Array $ array , int $ length , array $ refs )Parâmetros:
$array - UINT8Array da representação de BitString da célula$length - comprimento da bitsstring$refs - fatias de células infantis Retorna os bits não lidos de acordo com o cursor interno.
/**
* @param int $n
*/
public function get( int $ n ): bool Retorna um pouco de valor na posição $n .
Lê um pouco e move o cursor.
/**
* @param int $bitLength
*/
public function loadBits( int $ bitLength ): Uint8ArrayLê o conjunto de bits.
/**
* @param int $bitLength
*/
public function loadUint( int $ bitLength ): BigIntegerLê o número inteiro não assinado.
/**
* @param int $bitLength
*/
public function loadInt( int $ bitLength ): BigIntegerLeia o número inteiro assinado.
/**
* @param int $bitLength
*/
public function loadVarUint( int $ bitLength ): BigInteger Lê o valor TON em nanotoncoins.
Lê o endereço.
Lê fatia de célula infantil.
composer run testMit
