boc
0.4.1
olifanton/interop . PORT DE PHP de la bibliothèque JS tonweb-boc
composer require olifanton/boc Installez le package olifanton/boc via Composer et incluez le script 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 est une classe qui vous permet de manipuler des données binaires. BitString est au cœur de la représentation PHP des cellules TVM. BitString est optimisé par la mémoire pour stocker les données binaires. En interne, BitString utilise l'implémentation de Uint8Array fourni par le package ajf/typed-arrays et est utilisé comme type de base pour transférer des données binaires entre des parties des bibliothèques Olifanton.
L'instance Bitstring est créée avec une longueur strictement fixe. Les méthodes write% (writebit, writeUint, ...) déplacent le curseur interne. Si vous essayez d'écrire une valeur qui dépasse la longueur des bits libres, l'exception BitStringException sera lancée.
/**
* @param int $length
*/
public function __construct( int $ length )Paramètres:
$length - Longueur de Uint8Array. Valeur par défaut pour la cellule TVM: 1023 (documentation) Renvoie des bits inutilisés longueur de bitstring.
Renvoie des bits utilisés Longueur de Bitstring.
Renvoie des octets utilisés Longueur de Bitsstring.
/**
* @param int $n Position
*/
public function get( int $ n ): bool Renvoie un peu de valeur en position $n .
/**
* @param int $n Position
*/
public function on( int $ n ): void Définit un peu de valeur sur 1 en position $n .
/**
* @param int $n Position
*/
public function off( int $ n ): void Définit une valeur un peu sur 0 en position $n .
/**
* @param int $n Position
*/
public function toggle( int $ n ): void Basciller la valeur bit (inverse) en position $n .
Renvoie un générateur de bits utilisés.
Exemple:
<?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 ): voidÉcrit et augmente le curseur interne Bitstring.
/**
* @param array<int | bool> $ba Array of bits
*/
public function writeBitArray( array $ ba ): voidÉcrit une gamme de bits.
Exemple:
<?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 ): voidÉcrit $ 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 ): voidÉcrit entier signé $ BitLength-bits.
Alias de la méthode writeUint() avec une valeur de paramètre Bitlengle prédéfinie.
/**
* @param ajfTypedArraysUint8Array $ui8 Byte array
*/
public function writeBytes( Uint8Array $ ui8 ): voidÉcrivez la gamme d'entiers 8 bits non signés.
/**
* @param string $value
*/
public function writeString( string $ value ): voidÉcrit la chaîne UTF-8.
/**
* @param int|BrickMathBigInteger $amount
*/
public function writeCoins( int | BigInteger $ amount ): void ;Écrit des pièces dans les nanotoncoins. 1 tonne === 1000000000 (10 ^ 9) Nanotoncoins.
/**
* @param OlifantonUtilsAddress|null $address TON Address
*/
public function writeAddress(? Address $ address ): voidÉcrit Ton Adresse. Voir la mise en œuvre de l'adresse dans le package Olifanton / Utils.
/**
* @param OlifantonBocBitString $anotherBitString BitString instance
*/
public function writeBitString( BitString $ anotherBitString ): voidÉcrit un autre bittring à ce bitstring.
Clones Cetstring et renvoie une nouvelle instance Bitstring.
Renvoie une représentation de chaîne hexagonale de Bitstring.
Renvoie une copie immuable de Uint8Array interne.
Renvoie la taille de Bitstring en bits.
OlifantonBocCell Cell est une classe qui met en œuvre le concept de cellules TVM dans PHP. Pour créer des messages nouveaux et processus reçus de la blockchain, vous travaillerez avec les instances de la classe de cellules.
Sans paramètres.
/**
* @param string|Uint8Array $serializedBoc Serialized BoC
* @return Cell[]
*/
public static function fromBoc( string | Uint8Array $ serializedBoc ): arrayCrée une table de cellules à partir du tableau d'octets ou de la chaîne hexagonale.
/**
* @param string|Uint8Array $serializedBoc Serialized BoC
* @param bool $isBase64 Base64-serialized flag, default false
*/
public static function oneFromBoc( string | Uint8Array $ serializedBoc , bool $ isBase64 = false ): CellReportez une cellule racine du tableau d'octets ou de la chaîne hexagonale.
/**
* @param Cell $anotherCell Another cell
* @return Cell This Cell
*/
public function writeCell( Cell $ anotherCell ): selfÉcrit une autre cellule à cette cellule et renvoie cette cellule. Méthode mutable.
Renvoie la profondeur maximale des cellules enfants.
Renvoie l'instance Bitstring interne pour l'écriture et la lecture.
Renvoie un objet de type tableau des cellules pour enfants.
Renvoie le hachage SHA-256 de cette cellule.
Recursivement imprime le contenu de Cell comme 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 ): Uint8ArrayCrée un tableau d'octets BOC.
OlifantonBocSlice Slice est le type de tranches cellulaires. Une cellule peut être transformée en tranche, puis les bits de données et les références à d'autres cellules de la cellule peuvent être obtenus en les chargeant à partir de la tranche.
Méthodes load% (chargement, chargeUint, ...) Déplacez le curseur interne de tranche. Si vous essayez de lire une valeur qui dépasse la longueur des bits libres, une exception SliceException sera lancée.
/**
* @param ajfTypedArraysUint8Array $array
* @param int $length
* @param OlifantonBocSlice[] $refs
*/
public function __construct( Uint8Array $ array , int $ length , array $ refs )Paramètres:
$array - uint8array à partir de la représentation de Bitstring de cellule$length - Longueur Bitstring$refs - Les enfants de cellules Renvoie les bits non lus selon le curseur interne.
/**
* @param int $n
*/
public function get( int $ n ): bool Renvoie un peu de valeur en position $n .
Lit un peu et déplace le curseur.
/**
* @param int $bitLength
*/
public function loadBits( int $ bitLength ): Uint8ArrayLire le tableau de bits.
/**
* @param int $bitLength
*/
public function loadUint( int $ bitLength ): BigIntegerLit un entier non signé.
/**
* @param int $bitLength
*/
public function loadInt( int $ bitLength ): BigIntegerLire entier signé.
/**
* @param int $bitLength
*/
public function loadVarUint( int $ bitLength ): BigInteger Lit un montant de tonne dans les nanotoncoins.
Lit l'adresse.
Lit la tranche de cellule des enfants.
composer run testMit
