@layerzerolabs/ton-sdk-tools 3.0.84 → 3.0.85

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-import { Cell, Address, SendMode, Contract, ContractProvider, Sender, SenderArguments, Builder, OpenedContract, TupleReader, ContractState, TupleItem, Transaction, TransactionComputeVm, Message } from '@ton/core';
+import { Cell, Address, Dictionary, SendMode, Contract, ContractProvider, Sender, SenderArguments, Builder, OpenedContract, TupleReader, ContractState, TupleItem, Transaction, TransactionComputeVm, Message, MessageRelaxed, DictionaryValue } from '@ton/core';
 import { SandboxContract, BlockchainTransaction, Blockchain, Treasury, SendMessageResult, TreasuryContract } from '@ton/sandbox';
 import { FlatTransactionComparable } from '@ton/test-utils';
+import { KeyPair } from '@ton/crypto';
+import { WalletContractV4 } from '@ton/ton';
 
 interface ConstructorArgs {
     [key: string]: string;
@@ -71,34 +73,73 @@ declare function saveConstantsFile(constants: Map<string, bigint>, directory: st
 declare function generateAllViewFunctions(rootDir: string, nameWhitelist: string[], blacklist: string[]): TonViewFunctionsDict;
 declare function saveViewFunctions(viewFunctions: TonViewFunctionsDict, directory: string, filename: string): void;
 
+declare const cl: {
+    readonly t: {
+        readonly uint1: 0;
+        readonly bool: 0;
+        readonly uint2: 1;
+        readonly uint4: 2;
+        readonly uint8: 3;
+        readonly uint16: 4;
+        readonly uint32: 5;
+        readonly uint64: 6;
+        readonly uint128: 7;
+        readonly coins: 7;
+        readonly uint256: 8;
+        readonly address: 8;
+        readonly cellRef: 9;
+        readonly dict256: 9;
+        readonly objRef: 9;
+        readonly addressList: 9;
+    };
+    readonly NULL_CLASS_NAME: "NULL";
+    readonly ERROR: {
+        readonly INVALID_CLASS: "INVALID_CLASS";
+    };
+};
+declare const NAME_WIDTH: number;
+declare const MAX_CELL_BITS = 1023;
+type ClassTypeLike = Cell;
+type NumberTypeLike = string | bigint | number;
+type BoolTypeLike = NumberTypeLike | boolean;
+type AddressTypeLike = Address | string | bigint;
+type AddressListTypeLike = AddressTypeLike[] | Cell;
+type DecodedAndRaw<T, _Cell extends Cell = Cell> = T & {
+    rawCell: _Cell;
+};
+type DictionaryTypeLike<V> = Dictionary<bigint, V> | Cell | DecodedAndRaw<object>;
+interface ClDeclareCellField {
+    type: typeof cl.t.objRef;
+    value: Cell;
+}
+interface ClDeclareNumericField {
+    type: (typeof cl.t)[keyof Omit<typeof cl.t, 'objRef' | 'cellRef' | 'dict256'>];
+    value: NumberTypeLike | BoolTypeLike | AddressTypeLike;
+    typeMetadata: keyof (typeof cl)['t'];
+}
+type ClDeclareField = ClDeclareCellField | ClDeclareNumericField;
 /**
- * Wraps a blueprint-like artifact in a `Cell`. The constrains on the input type are loosened
- * and only the `hex` property is made required.
- *
- * @param artifact Blueprint JSON artifact object
- * @returns {Cell}
+ * Throws an error if value is smaller than -1
  */
-interface BlueprintArtfiact {
-    hex: string;
-    hash?: string;
-    hashBase64?: string;
-}
-declare const cellFromArtifact: ({ hex }: BlueprintArtfiact) => Cell;
-declare function getOpcodeCRC(input: string): bigint;
-declare const MASTER_CHAIN_ID = -1;
-declare const BASE_CHAIN_ID = 0;
-declare const MASTER_CHAIN_SHARD = "8000000000000000";
-declare function bigintToAddress(value: bigint): Address;
-declare const addressToBigInt: (address: Address) => bigint;
+declare const numberTypeLikeToAbsBigInt: (val: NumberTypeLike | BoolTypeLike | AddressTypeLike, typeMetadata?: keyof (typeof cl)['t']) => bigint;
+declare const _getTypeWidth: (clType: (typeof cl.t)[keyof typeof cl.t]) => number;
+declare const clDeclare: (name: bigint, fields: ClDeclareField[]) => Cell;
+declare const clGetUint: (cell: Cell, fieldName: number, width: number) => bigint;
+declare const clGetCellRef: (cell: Cell, fieldName: number) => Cell;
+
 /**
  * Convert a value to a 32 byte buffer, if the value is a string, it can only be a hex string
  * @param value
  * @param maxIntermediateBufferSize
  */
 declare function to32ByteBuffer(value: bigint | number | string | Uint8Array, maxIntermediateBufferSize?: number): Buffer;
-declare function findDeepestCell(cell: Cell): {
-    subTreeCells: number;
-};
+declare function trim0x(str: string): string;
+declare function bigintToAddress(value: bigint): Address;
+declare const parseTonAddress: (address: AddressTypeLike) => Address;
+declare const bigIntToHex: (bigInt: bigint) => string;
+declare const addressToHex: (address: AddressTypeLike) => string;
+declare const addressToBigInt: (address: AddressTypeLike) => bigint;
+declare const compareAddresses: (addressA: AddressTypeLike, addressB: AddressTypeLike) => boolean;
 
 interface SendRequestOptions {
     value: number | bigint | string;
@@ -500,6 +541,447 @@ declare function sendMessageViaMultisigAndExpect({ blockchain, multiSigContract,
 declare function sendInternalMessageAndExpect({ sender, contract, opCode, md, expectedTransactions, value, balanceRefill, queryId, profile, recursiveDecode, txDecoder, invertedOpcodes, }: SendInternalMessageAndExpectArgs): Promise<SendMessageResult>;
 declare function toHaveTransactions(actualTransactions: BlockchainTransaction[], expectedTransactions: FlatTransactionComparable[]): void;
 
+declare const MASTER_CHAIN_ID = -1;
+declare const BASE_CHAIN_ID = 0;
+declare const MASTER_CHAIN_SHARD = "8000000000000000";
+declare const PUBLIC_KEY_BYTE_LENGTH = 64;
+declare function publicKeyToHash(publicKey: Uint8Array): bigint;
+declare function createVerifierDictSet(verifiers: Uint8Array[]): Cell;
+declare const getBocStringFromMessage: (message: MessageRelaxed) => string;
+declare const getMessageFromBocString: (bocString: string) => MessageRelaxed;
+/**
+ * Wraps a blueprint-like artifact in a `Cell`. The constrains on the input type are loosened
+ * and only the `hex` property is made required.
+ *
+ * @param artifact Blueprint JSON artifact object
+ * @returns {Cell}
+ */
+interface BlueprintArtfiact {
+    hex: string;
+    hash?: string;
+    hashBase64?: string;
+}
+declare const cellFromArtifact: ({ hex }: BlueprintArtfiact) => Cell;
+declare function getOpcodeCRC(input: string): bigint;
+declare function findDeepestCell(cell: Cell): {
+    subTreeCells: number;
+};
+
 declare function openAndDeployAllStoragesTemplate(blockchain: Blockchain, deployer: SandboxContract<TreasuryContract>, artifact: BlueprintArtfiact, gasValue: bigint, opCode: bigint, md: Cell): Promise<SandboxContract<ClasslibWrapper>>;
 
-export { type Action, type Attribute, BASE_CHAIN_ID, BaseWrapper, type BlueprintArtfiact, ClasslibWrapper, type ConstructorArgs, type ConstructorCallGenerator, Errors, type ExtendedContract, type FieldMap, type GasInfo, type GetIntFnNames, type InverseFieldMap, JettonMinter, type JettonMinterConfig, type JettonMinterContent, JettonWallet, type JettonWalletConfig, MASTER_CHAIN_ID, MASTER_CHAIN_SHARD, type Module, MultiSigErrors, MultiSigOpCodes, MultiSigParams, Multisig, type MultisigConfig, type MultisigData, Op, Order, type OrderFullConfig, type OrderInitConfig, type Profile, type SendInternalMessageAndExpectArgs, type SendMessageViaMultisigAndExpectArgs, type SendRequestOptions, type TonObject, type TonObjectsDict, type TonViewFunction, type TonViewFunctionsDict, type TransferRequest, Txiterator, type UpdateRequest, addressToBigInt, bigintToAddress, buildOnchainMetadata, cellFromArtifact, computedGeneric, differentAddress, executeFrom, executeTill, extractErrors, extractEvents, extractOpcodes, findDeepestCell, findTransaction, formatCoinsPure, generateAllConstructorCodes, generateAllDeconstructorCodes, generateAllTonClassTypes, generateAllViewFunctions, generateCommonTestUtils, generateConstructorCode, generateDeconstructorCode, generateSmlTestUtils, generateTonClassType, generateUlnTestUtils, getMsgPrices, getOpcodeCRC, getRandom, getRandomInt, getSpecificFiles, jettonContentToCell, jettonMinterConfigToCell, jettonWalletConfigToCell, makeSnakeCell, mergeConstructorDicts, multisigConfigToCell, openAndDeployAllStoragesTemplate, orderConfigToCell, parseDirectory, printTransactionTrace, saveAllTypes, saveBaseEventHandler, saveConstantsFile, saveEventsFile, saveLzEventHandler, saveLzGasTracker, saveObjectsAsTS, saveTonContractWrapper, saveTonObjectUnwrapper, saveViewFunctions, sendInternalMessageAndExpect, sendMessageViaMultisigAndExpect, setLzTonSdkSaveToJson, setLzTonSdkWriteToConsole, storageCollected, to32ByteBuffer, toHaveTransactions };
+declare function toPathArray(path: string): number[];
+declare function getTonWalletFromMnemonic(mnemonic: string, path?: string, workchain?: number): Promise<{
+    wallet: WalletContractV4;
+    keyPair: KeyPair;
+}>;
+declare const getTonWalletFromMnemonicLegacy: (mnemonic: string, workchain?: number) => Promise<{
+    wallet: WalletContractV4;
+    keyPair: KeyPair;
+}>;
+
+type ValueOf<T> = T[keyof T];
+declare const fieldTypes: readonly ["cl::t::uint1", "cl::t::bool", "cl::t::uint2", "cl::t::uint4", "cl::t::uint8", "cl::t::uint16", "cl::t::uint32", "cl::t::uint64", "cl::t::uint128", "cl::t::coins", "cl::t::uint256", "cl::t::address", "cl::t::dict256", "cl::t::cellRef", "cl::t::objRef", "cl::t::addressList"];
+interface TonObjects {
+    [key: string]: {
+        name: string;
+    } & {
+        [key in `${number}`]: {
+            fieldName: string;
+            fieldType: FieldTypes<TonObjects>;
+        };
+    };
+}
+type TonObjectsKeys<_TonObjects extends TonObjects> = keyof _TonObjects & string;
+type FieldTypes<_TonObjects extends TonObjects> = (typeof fieldTypes)[number] | TonObjectsKeys<_TonObjects>;
+type ClassDefinition<_TonObjects extends TonObjects, ClassName extends TonObjectsKeys<_TonObjects>> = Omit<_TonObjects[ClassName], 'name'>;
+type EnhancedAddress = Address & {
+    toHex: () => string;
+    toBigInt: () => bigint;
+};
+type EnhancedAddressList = EnhancedAddress[] & {
+    toHex: () => string[];
+    toBigInt: () => bigint[];
+};
+type EnhancedCell<_TonObjects extends TonObjects> = Cell & {
+    getAddressList: () => EnhancedAddressList;
+    cellsToHex: () => string;
+    getDict: <V>(valueType: DictionaryValue<V>) => Dictionary<bigint, V>;
+    decode: <ClassName extends TonObjectsKeys<_TonObjects>>(className: ClassName) => Fields<_TonObjects, ClassName>;
+    clGetCellRef: (index: number) => EnhancedCell<_TonObjects>;
+    clGetUint: (index: number, width: number) => bigint;
+    getCellName: () => string;
+};
+type LoadableDict<_TonObjects extends TonObjects> = DecodedAndRaw<{
+    getDict: <V>(valueType: DictionaryValue<V>) => Dictionary<bigint, V>;
+}, EnhancedCell<_TonObjects>>;
+type FieldTypeToValue<_TonObjects extends TonObjects, FieldType, ClassType extends ClassTypeLike | EnhancedCell<_TonObjects>, NumberType extends NumberTypeLike, BoolType extends BoolTypeLike, AddressType extends AddressTypeLike, AddressListType extends AddressListTypeLike, DictionaryType extends DictionaryTypeLike<any>> = FieldType extends TonObjectsKeys<_TonObjects> ? [
+    ClassTypeLike
+] extends [ClassType] ? // eslint-disable-next-line no-use-before-define
+Fields<_TonObjects, FieldType, ClassType, NumberType, BoolType, AddressType, AddressListType> | ClassType : DecodedAndRaw<Fields<_TonObjects, FieldType, ClassType, NumberType, BoolType, AddressType, AddressListType>, EnhancedCell<_TonObjects>> : FieldType extends 'cl::t::cellRef' | 'cl::t::objRef' ? ClassType : FieldType extends 'cl::t::bool' ? BoolType : FieldType extends 'cl::t::address' ? AddressType : FieldType extends 'cl::t::addressList' ? AddressListType : FieldType extends 'cl::t::dict256' ? DictionaryType : NumberType;
+type Fields<_TonObjects extends TonObjects, ClassName extends TonObjectsKeys<_TonObjects>, ClassType extends ClassTypeLike | EnhancedCell<_TonObjects> = EnhancedCell<_TonObjects>, NumberType extends NumberTypeLike = bigint, BoolType extends BoolTypeLike = boolean, AddressType extends AddressTypeLike = EnhancedAddress, AddressListType extends AddressListTypeLike = EnhancedAddressList, DictionaryType extends DictionaryTypeLike<any> = LoadableDict<_TonObjects>> = ValueOf<ClassDefinition<_TonObjects, ClassName>> extends {
+    fieldName: string;
+    fieldType: FieldTypes<_TonObjects>;
+} ? {
+    [K in ValueOf<ClassDefinition<_TonObjects, ClassName>> as K['fieldName'] extends `${ClassName}::${infer PropName}` ? PropName : never]: FieldTypeToValue<_TonObjects, K['fieldType'], ClassType, NumberType, BoolType, AddressType, AddressListType, DictionaryType>;
+} : never;
+declare const isClassName: <_TonObjects extends TonObjects>(_tonObjects: _TonObjects, fieldType: FieldTypes<_TonObjects>) => fieldType is TonObjectsKeys<_TonObjects>;
+declare const generateEncodeClass: <_TonObjects extends TonObjects>(_tonObjects: _TonObjects) => <ClassName extends TonObjectsKeys<_TonObjects>>(_className: ClassName, fields: Fields<_TonObjects, ClassName, Cell, NumberTypeLike, BoolTypeLike, AddressTypeLike, AddressListTypeLike, DictionaryTypeLike<any>>) => Cell;
+declare const generateDecodeClass: <_TonObjects extends TonObjects>(_tonObjects: _TonObjects) => <ClassName extends TonObjectsKeys<_TonObjects>>(_className: ClassName, cell: Cell) => Fields<_TonObjects, ClassName, EnhancedCell<_TonObjects>, bigint, boolean, EnhancedAddress, EnhancedAddressList, LoadableDict<_TonObjects>>;
+declare const baseEncodeClass: <ClassName extends TonObjectsKeys<{
+    readonly POOO: {
+        readonly '0': {
+            readonly fieldName: "POOO::nextEmpty";
+            readonly fieldType: "cl::t::uint64";
+        };
+        readonly '1': {
+            readonly fieldName: "POOO::bitmap";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "POOO";
+    };
+    readonly BaseStorage: {
+        readonly '0': {
+            readonly fieldName: "BaseStorage::owner";
+            readonly fieldType: "cl::t::address";
+        };
+        readonly '1': {
+            readonly fieldName: "BaseStorage::authenticated";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '2': {
+            readonly fieldName: "BaseStorage::initialized";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '3': {
+            readonly fieldName: "BaseStorage::initialStorage";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "baseStore";
+    };
+    readonly 'action::event': {
+        readonly '0': {
+            readonly fieldName: "action::event::topic";
+            readonly fieldType: "cl::t::uint256";
+        };
+        readonly '1': {
+            readonly fieldName: "action::event::body";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly '2': {
+            readonly fieldName: "action::event::initialStorage";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly name: "event";
+    };
+}>>(_className: ClassName, fields: Fields<{
+    readonly POOO: {
+        readonly '0': {
+            readonly fieldName: "POOO::nextEmpty";
+            readonly fieldType: "cl::t::uint64";
+        };
+        readonly '1': {
+            readonly fieldName: "POOO::bitmap";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "POOO";
+    };
+    readonly BaseStorage: {
+        readonly '0': {
+            readonly fieldName: "BaseStorage::owner";
+            readonly fieldType: "cl::t::address";
+        };
+        readonly '1': {
+            readonly fieldName: "BaseStorage::authenticated";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '2': {
+            readonly fieldName: "BaseStorage::initialized";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '3': {
+            readonly fieldName: "BaseStorage::initialStorage";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "baseStore";
+    };
+    readonly 'action::event': {
+        readonly '0': {
+            readonly fieldName: "action::event::topic";
+            readonly fieldType: "cl::t::uint256";
+        };
+        readonly '1': {
+            readonly fieldName: "action::event::body";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly '2': {
+            readonly fieldName: "action::event::initialStorage";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly name: "event";
+    };
+}, ClassName, Cell, NumberTypeLike, BoolTypeLike, AddressTypeLike, AddressListTypeLike, DictionaryTypeLike<any>>) => Cell;
+declare const baseDecodeClass: <ClassName extends TonObjectsKeys<{
+    readonly POOO: {
+        readonly '0': {
+            readonly fieldName: "POOO::nextEmpty";
+            readonly fieldType: "cl::t::uint64";
+        };
+        readonly '1': {
+            readonly fieldName: "POOO::bitmap";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "POOO";
+    };
+    readonly BaseStorage: {
+        readonly '0': {
+            readonly fieldName: "BaseStorage::owner";
+            readonly fieldType: "cl::t::address";
+        };
+        readonly '1': {
+            readonly fieldName: "BaseStorage::authenticated";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '2': {
+            readonly fieldName: "BaseStorage::initialized";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '3': {
+            readonly fieldName: "BaseStorage::initialStorage";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "baseStore";
+    };
+    readonly 'action::event': {
+        readonly '0': {
+            readonly fieldName: "action::event::topic";
+            readonly fieldType: "cl::t::uint256";
+        };
+        readonly '1': {
+            readonly fieldName: "action::event::body";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly '2': {
+            readonly fieldName: "action::event::initialStorage";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly name: "event";
+    };
+}>>(_className: ClassName, cell: Cell) => Fields<{
+    readonly POOO: {
+        readonly '0': {
+            readonly fieldName: "POOO::nextEmpty";
+            readonly fieldType: "cl::t::uint64";
+        };
+        readonly '1': {
+            readonly fieldName: "POOO::bitmap";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "POOO";
+    };
+    readonly BaseStorage: {
+        readonly '0': {
+            readonly fieldName: "BaseStorage::owner";
+            readonly fieldType: "cl::t::address";
+        };
+        readonly '1': {
+            readonly fieldName: "BaseStorage::authenticated";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '2': {
+            readonly fieldName: "BaseStorage::initialized";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '3': {
+            readonly fieldName: "BaseStorage::initialStorage";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "baseStore";
+    };
+    readonly 'action::event': {
+        readonly '0': {
+            readonly fieldName: "action::event::topic";
+            readonly fieldType: "cl::t::uint256";
+        };
+        readonly '1': {
+            readonly fieldName: "action::event::body";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly '2': {
+            readonly fieldName: "action::event::initialStorage";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly name: "event";
+    };
+}, ClassName, EnhancedCell<{
+    readonly POOO: {
+        readonly '0': {
+            readonly fieldName: "POOO::nextEmpty";
+            readonly fieldType: "cl::t::uint64";
+        };
+        readonly '1': {
+            readonly fieldName: "POOO::bitmap";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "POOO";
+    };
+    readonly BaseStorage: {
+        readonly '0': {
+            readonly fieldName: "BaseStorage::owner";
+            readonly fieldType: "cl::t::address";
+        };
+        readonly '1': {
+            readonly fieldName: "BaseStorage::authenticated";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '2': {
+            readonly fieldName: "BaseStorage::initialized";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '3': {
+            readonly fieldName: "BaseStorage::initialStorage";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "baseStore";
+    };
+    readonly 'action::event': {
+        readonly '0': {
+            readonly fieldName: "action::event::topic";
+            readonly fieldType: "cl::t::uint256";
+        };
+        readonly '1': {
+            readonly fieldName: "action::event::body";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly '2': {
+            readonly fieldName: "action::event::initialStorage";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly name: "event";
+    };
+}>, bigint, boolean, EnhancedAddress, EnhancedAddressList, LoadableDict<{
+    readonly POOO: {
+        readonly '0': {
+            readonly fieldName: "POOO::nextEmpty";
+            readonly fieldType: "cl::t::uint64";
+        };
+        readonly '1': {
+            readonly fieldName: "POOO::bitmap";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "POOO";
+    };
+    readonly BaseStorage: {
+        readonly '0': {
+            readonly fieldName: "BaseStorage::owner";
+            readonly fieldType: "cl::t::address";
+        };
+        readonly '1': {
+            readonly fieldName: "BaseStorage::authenticated";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '2': {
+            readonly fieldName: "BaseStorage::initialized";
+            readonly fieldType: "cl::t::bool";
+        };
+        readonly '3': {
+            readonly fieldName: "BaseStorage::initialStorage";
+            readonly fieldType: "cl::t::cellRef";
+        };
+        readonly name: "baseStore";
+    };
+    readonly 'action::event': {
+        readonly '0': {
+            readonly fieldName: "action::event::topic";
+            readonly fieldType: "cl::t::uint256";
+        };
+        readonly '1': {
+            readonly fieldName: "action::event::body";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly '2': {
+            readonly fieldName: "action::event::initialStorage";
+            readonly fieldType: "cl::t::objRef";
+        };
+        readonly name: "event";
+    };
+}>>;
+
+declare const asciiStringToBigint: (target: string) => bigint;
+declare const bigintToAsciiString: (target: bigint) => string;
+declare const getCellNameNumber: (cell: Cell) => bigint;
+declare const getCellName: (cell: Cell) => string;
+declare const emptyCell: () => Cell;
+declare const nullObject: () => Cell;
+declare const emptyMap: () => Cell;
+declare const emptyPOOO: () => Cell;
+declare const initBaseStorage: (owner: AddressTypeLike) => Cell;
+declare function serializeAddressList(addresses: AddressListTypeLike): Cell;
+declare function deserializeAddressList(cell: Cell): bigint[];
+declare function serializePayees(payeesInfo: {
+    address: AddressTypeLike;
+    amount: NumberTypeLike;
+}[]): Cell;
+declare function deserializePayees(serializedPayees: Cell): {
+    address: string;
+    amount: bigint;
+}[];
+
+type Primitive = string | number | bigint | any[] | boolean | object;
+/**
+ * Recursively traverses a TON cell, deciding how to decode each node based on
+ * the class names stored in the cell.
+ * @param cell the root cell to begin decoding from.
+ * @param hashUndecodeable if TRUE, cells that can't be decoded will be hashed. if FALSE, they will be returned unchanged.
+ * This does not apply to primitive values.
+ * @returns an object whose fields are each the fields of the decoded cell, and whose (cell) fields are themselves decoded.
+ */
+declare const deepDecode: <Recurse extends {
+    [key: string]: Recurse;
+}, ClassName extends "POOO", DecodeClass extends (name: ClassName, cell: Cell) => {
+    [key: string]: any;
+}>(decodeClass: DecodeClass, cell: Cell | Primitive, hashUndecodeable?: boolean) => any;
+declare const printDeepDecode: <Recurse extends {
+    [key: string]: Recurse;
+}, ClassName extends "POOO", DecodeClass extends (name: ClassName, cell: Cell) => {
+    [key: string]: any;
+}>(decodeClass: DecodeClass, cell: Cell | Primitive) => void;
+
+/**
+ * Deeply compare two TON cells.
+ * @param cellA
+ * @param cellB
+ * @returns an object with a list of all values that differ between the two cells. Each inequal value is {a, b, ancestry},
+ * where a and b are the values of cellA and cellB respectively, and ancestry is an array [p_0 ... p_n] s.t. p_i is the name
+ * of the field accessed at both cellA and cellB _i_ deep.
+ * This function returns _every_ difference between the two cells, except in the case where,
+ * e.g., cellA = {subObject: 'hello world'}, cellB = {sub: {a, b, c: {x, y, z}}}--inequalValues = {a: 'hello world', b: [Object object], ancestry: ['Cell', 'subObject'].
+ * I.e., it is unable to detect sub-failures after ancestry diverges.
+ */
+declare const deepDiff: <ClassName extends "POOO", DecodeClass extends (name: ClassName, cell: Cell) => {
+    [key: string]: any;
+}>(decodeClass: DecodeClass, cellA: Cell, cellB: Cell) => {
+    isEqual: boolean;
+    inequalValues: {
+        a: any;
+        b: any;
+        ancestry: string[];
+    }[];
+};
+declare const printDeepDiff: <ClassName extends "POOO", DecodeClass extends (name: ClassName, cell: Cell) => {
+    [key: string]: any;
+}>(decodeClass: DecodeClass, cellA: Cell, cellB: Cell) => void;
+
+declare const hexToCells: (hex: string) => Cell;
+declare const getTotalBits: (cell: Cell) => number;
+declare const getClosestByteAlignedBits: (bits: number) => number;
+declare const cellsToHex: (cell: Cell) => string;
+declare const calculateCellConsumption: (cell: Cell) => {
+    numberOfCells: number;
+    bits: number;
+};
+declare const calculateCellConsumptionFromHex: (hex: string) => {
+    numberOfCells: number;
+    bits: number;
+};
+
+export { type Action, type AddressListTypeLike, type AddressTypeLike, type Attribute, BASE_CHAIN_ID, BaseWrapper, type BlueprintArtfiact, type BoolTypeLike, type ClDeclareCellField, type ClDeclareField, type ClDeclareNumericField, type ClassDefinition, type ClassTypeLike, ClasslibWrapper, type ConstructorArgs, type ConstructorCallGenerator, type DecodedAndRaw, type DictionaryTypeLike, type EnhancedAddress, type EnhancedAddressList, type EnhancedCell, Errors, type ExtendedContract, type FieldMap, type FieldTypeToValue, type FieldTypes, type Fields, type GasInfo, type GetIntFnNames, type InverseFieldMap, JettonMinter, type JettonMinterConfig, type JettonMinterContent, JettonWallet, type JettonWalletConfig, type LoadableDict, MASTER_CHAIN_ID, MASTER_CHAIN_SHARD, MAX_CELL_BITS, type Module, MultiSigErrors, MultiSigOpCodes, MultiSigParams, Multisig, type MultisigConfig, type MultisigData, NAME_WIDTH, type NumberTypeLike, Op, Order, type OrderFullConfig, type OrderInitConfig, PUBLIC_KEY_BYTE_LENGTH, type Profile, type SendInternalMessageAndExpectArgs, type SendMessageViaMultisigAndExpectArgs, type SendRequestOptions, type TonObject, type TonObjects, type TonObjectsDict, type TonObjectsKeys, type TonViewFunction, type TonViewFunctionsDict, type TransferRequest, Txiterator, type UpdateRequest, type ValueOf, _getTypeWidth, addressToBigInt, addressToHex, asciiStringToBigint, baseDecodeClass, baseEncodeClass, bigIntToHex, bigintToAddress, bigintToAsciiString, buildOnchainMetadata, calculateCellConsumption, calculateCellConsumptionFromHex, cellFromArtifact, cellsToHex, cl, clDeclare, clGetCellRef, clGetUint, compareAddresses, computedGeneric, createVerifierDictSet, deepDecode, deepDiff, deserializeAddressList, deserializePayees, differentAddress, emptyCell, emptyMap, emptyPOOO, executeFrom, executeTill, extractErrors, extractEvents, extractOpcodes, fieldTypes, findDeepestCell, findTransaction, formatCoinsPure, generateAllConstructorCodes, generateAllDeconstructorCodes, generateAllTonClassTypes, generateAllViewFunctions, generateCommonTestUtils, generateConstructorCode, generateDecodeClass, generateDeconstructorCode, generateEncodeClass, generateSmlTestUtils, generateTonClassType, generateUlnTestUtils, getBocStringFromMessage, getCellName, getCellNameNumber, getClosestByteAlignedBits, getMessageFromBocString, getMsgPrices, getOpcodeCRC, getRandom, getRandomInt, getSpecificFiles, getTonWalletFromMnemonic, getTonWalletFromMnemonicLegacy, getTotalBits, hexToCells, initBaseStorage, isClassName, jettonContentToCell, jettonMinterConfigToCell, jettonWalletConfigToCell, makeSnakeCell, mergeConstructorDicts, multisigConfigToCell, nullObject, numberTypeLikeToAbsBigInt, openAndDeployAllStoragesTemplate, orderConfigToCell, parseDirectory, parseTonAddress, printDeepDecode, printDeepDiff, printTransactionTrace, publicKeyToHash, saveAllTypes, saveBaseEventHandler, saveConstantsFile, saveEventsFile, saveLzEventHandler, saveLzGasTracker, saveObjectsAsTS, saveTonContractWrapper, saveTonObjectUnwrapper, saveViewFunctions, sendInternalMessageAndExpect, sendMessageViaMultisigAndExpect, serializeAddressList, serializePayees, setLzTonSdkSaveToJson, setLzTonSdkWriteToConsole, storageCollected, to32ByteBuffer, toHaveTransactions, toPathArray, trim0x };