@layerzerolabs/ton-sdk-tools 3.0.87 → 3.0.89

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @layerzerolabs/ton-sdk-tools
 
+## 3.0.89
+
+### Patch Changes
+
+- 49985f3: testnets
+
+## 3.0.88
+
+### Patch Changes
+
+- d0cda5e: ton sdk-tools refactored, added rawDispatch action to funC++
+
 ## 3.0.87
 
 ### Patch Changes

package/dist/index.cjs

@@ -4,6 +4,7 @@ var fs = require('fs');
 var path = require('path');
 var core = require('@ton/core');
 var crc32 = require('crc-32');
+var ethers = require('ethers');
 var bigintBuffer = require('bigint-buffer');
 var Event = require('@ton/sandbox/dist/event/Event');
 var testUtils = require('@ton/test-utils');
@@ -34,15 +35,85 @@ var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var crc32__namespace = /*#__PURE__*/_interopNamespace(crc32);
 
 // src/sdk-tools.ts
+function to32ByteBuffer(value, maxIntermediateBufferSize = 66) {
+  if (typeof value === "string") {
+    if (!isValidHex(value)) {
+      throw new Error("only hex string is supported");
+    }
+    let hex = trim0x(value);
+    if (hex.length % 2 !== 0) {
+      hex = "0" + hex;
+    }
+    value = bigintBuffer.toBigIntBE(Buffer.from(hex, "hex"));
+  }
+  if (value instanceof Uint8Array) {
+    value = bigintBuffer.toBigIntBE(Buffer.from(value));
+  }
+  const bf = bigintBuffer.toBufferBE(BigInt(value), maxIntermediateBufferSize);
+  return bf.subarray(-32);
+}
+function trim0x(str2) {
+  return str2.replace(/^0x/, "");
+}
+function isValidHex(str2) {
+  const hexRegex = /^(0x)?[0-9A-Fa-f]+$/;
+  return hexRegex.test(str2);
+}
+function bigintToAddress(value) {
+  const buf = to32ByteBuffer(value);
+  return core.Address.parse(`0:${buf.toString("hex")}`);
+}
+var parseTonAddress = (address) => {
+  if (address instanceof core.Address) {
+    return address;
+  }
+  if (typeof address === "bigint" || typeof address === "number") {
+    return bigintToAddress(BigInt(address));
+  }
+  if (address.startsWith("0x")) {
+    return bigintToAddress(BigInt(address));
+  }
+  try {
+    return core.Address.parse(address);
+  } catch (e) {
+    return bigintToAddress(BigInt(`0x${address}`));
+  }
+};
+var _addressToNotPaddedHex = (address) => {
+  return `0x${parseTonAddress(address).hash.toString("hex")}`;
+};
+var bigIntToHex = (bigInt) => {
+  return `0x${bigInt.toString(16)}`.toLowerCase();
+};
+var addressToHex = (address) => {
+  return `0x${to32ByteBuffer(_addressToNotPaddedHex(address)).toString("hex")}`.toLowerCase();
+};
+var addressToBigInt = (address) => {
+  return BigInt(_addressToNotPaddedHex(address));
+};
+var compareAddresses = (addressA, addressB) => {
+  return parseTonAddress(addressA).equals(parseTonAddress(addressB));
+};
+
+// src/utils.ts
 var MASTER_CHAIN_ID = -1;
 var BASE_CHAIN_ID = 0;
 var MASTER_CHAIN_SHARD = "8000000000000000";
 var PUBLIC_KEY_BYTE_LENGTH = 64;
+var SIGNATURE_BYTE_LENGTH = 65;
+var SEED_SIZE = 32;
 function publicKeyToHash(publicKey) {
   const publicKeyCell = core.beginCell().storeBuffer(Buffer.from(publicKey), PUBLIC_KEY_BYTE_LENGTH).endCell();
   const publicKeyHash = BigInt("0x" + publicKeyCell.hash().toString("hex"));
   return publicKeyHash;
 }
+function preprocessPublicKey(publicKey) {
+  const publicKeyBuffer = Buffer.from(publicKey.slice(2), "hex");
+  return publicKeyBuffer.subarray(1);
+}
+function stringPublicKeyToHash(publicKey) {
+  return publicKeyToHash(preprocessPublicKey(publicKey));
+}
 function createVerifierDictSet(verifiers) {
   const verifierDict = core.Dictionary.empty(core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell());
   for (const verifier of verifiers) {
@@ -50,6 +121,46 @@ function createVerifierDictSet(verifiers) {
   }
   return core.beginCell().storeDictDirect(verifierDict, core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell()).endCell();
 }
+function createVerifierDictSetFromStrings(publicKeys) {
+  const publicKeyBuffers = publicKeys.map((key) => preprocessPublicKey(key));
+  return createVerifierDictSet(publicKeyBuffers);
+}
+function createVerifierDictSetFromEtherWallets(verifiers) {
+  const publicKeys = verifiers.map((key) => key.publicKey);
+  return createVerifierDictSetFromStrings(publicKeys);
+}
+function createAdminDictSet(admins) {
+  const verifierDict = core.Dictionary.empty(core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell());
+  for (const admin of admins) {
+    verifierDict.set(addressToBigInt(admin.address), core.beginCell().endCell());
+  }
+  return core.beginCell().storeDictDirect(verifierDict, core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell()).endCell();
+}
+function createSignatures(hash, verifiers) {
+  const signatures = core.Dictionary.empty(core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell());
+  for (const verifier of verifiers) {
+    const signature = verifier._signingKey().signDigest(hash);
+    const signatureBytes = ethers.ethers.utils.splitSignature(signature);
+    const signatureBytesArray = new Uint8Array([
+      ...ethers.ethers.utils.arrayify(signatureBytes.r),
+      ...ethers.ethers.utils.arrayify(signatureBytes.s),
+      signatureBytes.v
+    ]);
+    signatures.set(
+      stringPublicKeyToHash(verifier.publicKey),
+      core.beginCell().storeBuffer(Buffer.from(signatureBytesArray), SIGNATURE_BYTE_LENGTH).endCell()
+    );
+  }
+  return core.beginCell().storeDictDirect(signatures, core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell()).endCell();
+}
+function generateRandomVerifierSet(count) {
+  const verifiers = [];
+  for (let i = 0; i < count; i++) {
+    const privateKey = ethers.ethers.utils.randomBytes(SEED_SIZE);
+    verifiers.push(new ethers.ethers.Wallet(privateKey));
+  }
+  return verifiers;
+}
 var getBocStringFromMessage = (message) => {
   return core.beginCell().store(core.storeMessageRelaxed(message)).endCell().toBoc().toString("base64");
 };
@@ -74,6 +185,16 @@ function findDeepestCell(cell) {
   }
   return { subTreeCells: size };
 }
+function addLibToBlockchain(blockchain, newLib) {
+  let libsDict;
+  if (blockchain.libs) {
+    libsDict = blockchain.libs.beginParse().loadDictDirect(core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell());
+  } else {
+    libsDict = core.Dictionary.empty(core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell());
+  }
+  libsDict.set(BigInt(`0x${newLib.hash().toString("hex")}`), newLib);
+  blockchain.libs = core.beginCell().storeDictDirect(libsDict).endCell();
+}
 
 // src/sdk-tools.ts
 var file_signature_header = `////// Generated by sdk/sdk-generator.ts`;
@@ -345,11 +466,11 @@ function saveBaseEventHandler(directory, opcodesImportPath = "../constants", all
 import { Cell, Transaction, TransactionComputeVm, TransactionDescriptionGeneric, beginCell } from '@ton/core'
 import { BlockchainTransaction, EventMessageSent, SendMessageResult } from '@ton/sandbox'
 import { flattenTransaction } from '@ton/test-utils'
-import { ExtendedContract } from '${baseWrapperImportPath}'
+import { ExtendedContract, getLzDict } from '${baseWrapperImportPath}'
 
 import { OPCODES } from '${opcodesImportPath}'
 
-import { getLzDict,
+import {
 ${allTypes.map((type) => "    " + type + ",\n").join("")}} from '${allTypesImportPath}'
 
 import { TonObjectUnwrapper } from '${tonObjectUnwrapperImportPath}'
@@ -546,40 +667,7 @@ import { Cell, OpenedContract, beginCell } from '@ton/core'
 import { SandboxContract } from '@ton/sandbox'
 
 import { TonContractWrapper } from '${tonContractWrapperImportPath}'
-import { ExtendedContract } from '${baseWrapperImportPath}'
-
-export class LzDict {
-    _cell: Cell
-
-    constructor(data: Cell) {
-        this._cell = data
-    }
-
-    static empty(): LzDict {
-        return new LzDict(beginCell().endCell())
-    }
-
-    async getCell(key: bigint, wrapper: ExtendedContract<TonContractWrapper>): Promise<Cell> {
-        return wrapper.getDictCellItem(this._cell, key)
-    }
-
-    async getBigInt(key: bigint, wrapper: ExtendedContract<TonContractWrapper>): Promise<bigint> {
-        return wrapper.getDictUint256Item(this._cell, key)
-    }
-
-    async set(key: bigint, value: Cell, wrapper: ExtendedContract<TonContractWrapper>): Promise<void> {
-        this._cell = await wrapper.getSetDictItem(this._cell, key, value)
-    }
-
-    asCell(): Cell {
-        return this._cell
-    }
-}
-
-export async function getLzDict(obj: Cell, fieldName: bigint, wrapper: ExtendedContract<TonContractWrapper>): Promise<LzDict> {
-    const dictCell = await wrapper.getClDict(obj, fieldName)
-    return new LzDict(dictCell)
-}
+import { ExtendedContract, LzDict, getLzDict } from '${baseWrapperImportPath}'
 
 export interface Md {}
 
@@ -722,7 +810,6 @@ export class LzGasTracker {
 function saveTonObjectUnwrapper(tonObjects, directory, allTypesImportPath = "./allTypes", tonContractWrapperImportPath = "./TonContractWrapper", classlibWrapperImportPath = "@layerzerolabs/ton-sdk-tools", baseWrapperImportPath = "@layerzerolabs/ton-sdk-tools") {
   const allTypes = [
     ...Object.values(tonObjects).map((obj) => obj.tsTypeName).filter((name) => name !== void 0),
-    "LzDict",
     "Md",
     "nameMap"
   ].sort();
@@ -734,11 +821,11 @@ import { Cell, Transaction, TransactionComputeVm, TransactionDescriptionGeneric,
 import { BlockchainTransaction, EventMessageSent, SendMessageResult } from '@ton/sandbox'
 import { flattenTransaction } from '@ton/test-utils'
 
-import { getLzDict,
+import {
 ${allTypes.map((type) => "    " + type + ",\n").join("")}} from '${allTypesImportPath}'
 import { TonContractWrapper } from '${tonContractWrapperImportPath}'
 import { ClasslibWrapper } from '${classlibWrapperImportPath}'
-import { ExtendedContract } from '${baseWrapperImportPath}'
+import { ExtendedContract, LzDict, getLzDict } from '${baseWrapperImportPath}'
 
 export class TonObjectUnwrapper {
 ${Array.from(
@@ -1147,65 +1234,6 @@ function saveViewFunctions(viewFunctions, directory, filename) {
   }
   fs__namespace.writeFileSync(path__namespace.join(directory, filename), generated.join("\n"));
 }
-function to32ByteBuffer(value, maxIntermediateBufferSize = 66) {
-  if (typeof value === "string") {
-    if (!isValidHex(value)) {
-      throw new Error("only hex string is supported");
-    }
-    let hex = trim0x(value);
-    if (hex.length % 2 !== 0) {
-      hex = "0" + hex;
-    }
-    value = bigintBuffer.toBigIntBE(Buffer.from(hex, "hex"));
-  }
-  if (value instanceof Uint8Array) {
-    value = bigintBuffer.toBigIntBE(Buffer.from(value));
-  }
-  const bf = bigintBuffer.toBufferBE(BigInt(value), maxIntermediateBufferSize);
-  return bf.subarray(-32);
-}
-function trim0x(str2) {
-  return str2.replace(/^0x/, "");
-}
-function isValidHex(str2) {
-  const hexRegex = /^(0x)?[0-9A-Fa-f]+$/;
-  return hexRegex.test(str2);
-}
-function bigintToAddress(value) {
-  const buf = to32ByteBuffer(value);
-  return core.Address.parse(`0:${buf.toString("hex")}`);
-}
-var parseTonAddress = (address) => {
-  if (address instanceof core.Address) {
-    return address;
-  }
-  if (typeof address === "bigint" || typeof address === "number") {
-    return bigintToAddress(BigInt(address));
-  }
-  if (address.startsWith("0x")) {
-    return bigintToAddress(BigInt(address));
-  }
-  try {
-    return core.Address.parse(address);
-  } catch (e) {
-    return bigintToAddress(BigInt(`0x${address}`));
-  }
-};
-var _addressToNotPaddedHex = (address) => {
-  return `0x${parseTonAddress(address).hash.toString("hex")}`;
-};
-var bigIntToHex = (bigInt) => {
-  return `0x${bigInt.toString(16)}`.toLowerCase();
-};
-var addressToHex = (address) => {
-  return `0x${to32ByteBuffer(_addressToNotPaddedHex(address)).toString("hex")}`.toLowerCase();
-};
-var addressToBigInt = (address) => {
-  return BigInt(_addressToNotPaddedHex(address));
-};
-var compareAddresses = (addressA, addressB) => {
-  return parseTonAddress(addressA).equals(parseTonAddress(addressB));
-};
 var BaseWrapper = class {
   constructor(address, init) {
     this.address = address;
@@ -1410,11 +1438,12 @@ import {
     ExtendedContract,
     sendMessageViaMultisigAndExpect,
     sendInternalMessageAndExpect,
-    toHaveTransactions
+    LzDict,
+    toHaveTransactions,
+    addLibToBlockchain
 } from '@layerzerolabs/ton-sdk-tools'
 
 import {
-    LzDict,
     LzEventHandler,
     MdPacketSent,
     OPCODES,
@@ -1451,10 +1480,6 @@ export const newTonObjectsContainer: { items: { [key: string]: unknown } } = {
     items: {},
 }
 
-export const PUBLIC_KEY_BYTE_LENGTH = 64
-export const SIGNATURE_BYTE_LENGTH = 65
-const SEED_SIZE = 32
-
 // ==============================PROTOCOL SETUP GAS==============================
 
 // todo update these to be accurate when ready. To fragile now during development
@@ -1488,40 +1513,6 @@ export const OAppFlowGas = {
 
 export const emptyObject = beginCell().storeUint(0, 1).endCell()
 
-// ===============================INTERFACES===============================
-
-export function publicKeyToHash(publicKey: string): bigint {
-    // Remove '0x' prefix and convert to Buffer
-    const publicKeyBuffer = Buffer.from(publicKey.slice(2), 'hex')
-    // skip the first byte (h) as it's always 4
-    const publicKeyWithoutH = publicKeyBuffer.subarray(1)
-    const publicKeyCell = beginCell().storeBuffer(publicKeyWithoutH, PUBLIC_KEY_BYTE_LENGTH).endCell()
-    const publicKeyHash = BigInt('0x' + publicKeyCell.hash().toString('hex'))
-    return publicKeyHash
-}
-
-// ==============================VERIFIER SET==============================
-
-export function generateRandomVerifierSet(count: number): ethers.Wallet[] {
-    const verifiers: ethers.Wallet[] = []
-    for (let i = 0; i < count; i++) {
-        const privateKey = ethers.utils.randomBytes(SEED_SIZE)
-        verifiers.push(new ethers.Wallet(privateKey))
-    }
-    return verifiers
-}
-
-export async function createVerifierDictSet(
-    verifiers: ethers.Wallet[],
-    wrapper: ExtendedContract<TonContractWrapper>
-): Promise<Cell> {
-    const verifierDict = LzDict.empty()
-    for (const verifier of verifiers) {
-        await verifierDict.set(publicKeyToHash(verifier.publicKey), beginCell().endCell(), wrapper)
-    }
-    return verifierDict.asCell()
-}
-
 export function serializeAddressList(admins: SandboxContract<TreasuryContract | TonContractWrapper>[]): Cell {
     const addressList = admins.map((admin) => addressToBigInt(admin.address))
 
@@ -2013,17 +2004,6 @@ export async function getExecutionStatus(
     return (await contract.getViewFunction('_viewExecutionStatus', args)).readBigNumber()
 }
 
-export function addLibToBlockchain(blockchain: Blockchain, newLib: Cell): void {
-    let libsDict: Dictionary<bigint, Cell>
-    if (blockchain.libs) {
-        libsDict = blockchain.libs.beginParse().loadDictDirect(Dictionary.Keys.BigUint(256), Dictionary.Values.Cell())
-    } else {
-        libsDict = Dictionary.empty(Dictionary.Keys.BigUint(256), Dictionary.Values.Cell())
-    }
-    libsDict.set(BigInt(\`0x\${newLib.hash().toString('hex')}\`), newLib)
-    blockchain.libs = beginCell().storeDictDirect(libsDict).endCell()
-}
-
 // ===============================DEPLOYING CONTRACTS===============================
 
 export async function openAndDeployControllerViaMultiSig(
@@ -3160,7 +3140,7 @@ import ProxyArtifact from '@layerzerolabs/layerzero-v2-ton/build/Proxy.compiled.
 import UlnArtifact from '@layerzerolabs/layerzero-v2-ton/build/Uln.compiled.json'
 import UlnConnectionArtifact from '@layerzerolabs/layerzero-v2-ton/build/UlnConnection.compiled.json'
 import UlnManagerArtifact from '@layerzerolabs/layerzero-v2-ton/build/UlnManager.compiled.json'
-import { BlueprintArtfiact, ExtendedContract, Profile, addressToBigInt, cellFromArtifact, sendInternalMessageAndExpect, sendMessageViaMultisigAndExpect, } from '@layerzerolabs/ton-sdk-tools'
+import { BlueprintArtfiact, ExtendedContract, Profile, addressToBigInt, cellFromArtifact, sendInternalMessageAndExpect, sendMessageViaMultisigAndExpect, LzDict, createSignatures, createVerifierDictSetFromEtherWallets, generateRandomVerifierSet } from '@layerzerolabs/ton-sdk-tools'
 
 import {
     OAppFixture,
@@ -3169,9 +3149,7 @@ import {
     SIGNATURE_BYTE_LENGTH,
     addMsgLibToController,
     createLzPacketFromPacketEncoded,
-    createVerifierDictSet,
     emptyObject,
-    generateRandomVerifierSet,
     protocolSetupGas,
     publicKeyToHash,
     requireDefined,
@@ -3181,7 +3159,6 @@ import {
 } from './auto-utils-common'
 
 import {
-    LzDict,
     LzEventHandler,
     MdPacketSent,
     OPCODES,
@@ -3764,7 +3741,7 @@ export async function openAndDeployDvnAndProxy(
                 admins: serializeAddressList(adminSet),
                 version: version,
                 quorum: 1n,
-                verifiers: await createVerifierDictSet(verifierSet, allStorages),
+                verifiers: createVerifierDictSetFromEtherWallets(verifierSet),
             })
         )
     )
@@ -4833,61 +4810,6 @@ export const dvnSetupGas = {
     'Dvn.SEND_SIGNED_REQUEST': toNano('10'), // 0.235917
 }
 
-export async function createAdminDictSet(
-    admins: SandboxContract<TreasuryContract | TonContractWrapper>[],
-    wrapper: ExtendedContract<TonContractWrapper>
-): Promise<Cell> {
-    const adminDict = LzDict.empty()
-    for (const admin of admins) {
-        await adminDict.set(addressToBigInt(admin.address), beginCell().endCell(), wrapper)
-    }
-    return adminDict.asCell()
-}
-
-export async function createSignatures(
-    hash: Buffer,
-    verifiers: ethers.Wallet[],
-    wrapper: ExtendedContract<TonContractWrapper>
-): Promise<Cell> {
-    const signatures = LzDict.empty()
-    for (const verifier of verifiers) {
-        // doing this one insted of .signMessage() to not sign with the "Ethereum" prefix
-        const signature = verifier._signingKey().signDigest(hash)
-        const signatureBytes = ethers.utils.splitSignature(signature)
-        const signatureBytesArray = new Uint8Array([
-            ...ethers.utils.arrayify(signatureBytes.r),
-            ...ethers.utils.arrayify(signatureBytes.s),
-            signatureBytes.v,
-        ])
-
-        await signatures.set(
-            publicKeyToHash(verifier.publicKey),
-            beginCell().storeBuffer(Buffer.from(signatureBytesArray), SIGNATURE_BYTE_LENGTH).endCell(),
-            wrapper
-        )
-
-        // Sanity Check: Attempt to recover the public key from the signature
-        // const messageHash = ethers.utils.arrayify(hash)
-        // try {
-        //     const recoveredPublicKey = ethers.utils.recoverPublicKey(messageHash, signatureBytes)
-        //     const originalPublicKey = verifier.publicKey
-
-        //     console.log(\`Verifier:\`)
-        //     console.log(\`Original public key: \${originalPublicKey}\`)
-        //     console.log(\`Recovered public key: \${recoveredPublicKey}\`)
-
-        //     if (recoveredPublicKey.toLowerCase() === originalPublicKey.toLowerCase()) {
-        //         console.log('Public key successfully recovered!')
-        //     } else {
-        //         console.log('Public key recovery failed.')
-        //     }
-        // } catch (error) {
-        //     console.error(\`Error recovering public key for verifier:\`, error)
-        // }
-    }
-    return signatures.asCell()
-}
-
 // ================================DVN: SEND REQUEST================================
 
 interface SignAndSendRequestToDvnParams {
@@ -4911,7 +4833,7 @@ export async function signAndSendRequestToDvn({
 }: SignAndSendRequestToDvnParams): Promise<SendMessageResult> {
     const signedRequest = await allStorages.getNewMdSignedRequest({
         request,
-        signatures: await createSignatures(request.hash(), verifierSet, allStorages),
+        signatures: createSignatures(request.hash(), verifierSet),
     })
 
     return sendInternalMessageAndExpect({
@@ -5178,7 +5100,7 @@ export async function ulnVerifyAndExpect(
             opCode: OPCODES.Dvn_OP_VERIFY,
             md: await allStorages.getNewMdSignedRequest({
                 request: requestMd,
-                signatures: await createSignatures(requestMd.hash(), verifiers, allStorages),
+                signatures: createSignatures(requestMd.hash(), verifiers),
             }),
             expectedTransactions: [
                 {
@@ -7015,6 +6937,30 @@ var printDeepDiff = (decodeClass, cellA, cellB) => {
     )
   );
 };
+var LzDict = class _LzDict {
+  constructor(data) {
+    this._cell = data;
+  }
+  static empty() {
+    return new _LzDict(core.beginCell().endCell());
+  }
+  async getCell(key, wrapper) {
+    return wrapper.getDictCellItem(this._cell, key);
+  }
+  async getBigInt(key, wrapper) {
+    return wrapper.getDictUint256Item(this._cell, key);
+  }
+  async set(key, value, wrapper) {
+    this._cell = await wrapper.getSetDictItem(this._cell, key, value);
+  }
+  asCell() {
+    return this._cell;
+  }
+};
+async function getLzDict(obj, fieldName, wrapper) {
+  const dictCell = await wrapper.getClDict(obj, fieldName);
+  return new LzDict(dictCell);
+}
 
 exports.BASE_CHAIN_ID = BASE_CHAIN_ID;
 exports.BaseWrapper = BaseWrapper;
@@ -7022,6 +6968,7 @@ exports.ClasslibWrapper = ClasslibWrapper;
 exports.Errors = Errors;
 exports.JettonMinter = JettonMinter;
 exports.JettonWallet = JettonWallet;
+exports.LzDict = LzDict;
 exports.MASTER_CHAIN_ID = MASTER_CHAIN_ID;
 exports.MASTER_CHAIN_SHARD = MASTER_CHAIN_SHARD;
 exports.MAX_CELL_BITS = MAX_CELL_BITS;
@@ -7033,8 +6980,11 @@ exports.NAME_WIDTH = NAME_WIDTH;
 exports.Op = Op;
 exports.Order = Order;
 exports.PUBLIC_KEY_BYTE_LENGTH = PUBLIC_KEY_BYTE_LENGTH;
+exports.SEED_SIZE = SEED_SIZE;
+exports.SIGNATURE_BYTE_LENGTH = SIGNATURE_BYTE_LENGTH;
 exports.Txiterator = Txiterator;
 exports._getTypeWidth = _getTypeWidth;
+exports.addLibToBlockchain = addLibToBlockchain;
 exports.addressToBigInt = addressToBigInt;
 exports.addressToHex = addressToHex;
 exports.asciiStringToBigint = asciiStringToBigint2;
@@ -7054,7 +7004,11 @@ exports.clGetCellRef = clGetCellRef;
 exports.clGetUint = clGetUint;
 exports.compareAddresses = compareAddresses;
 exports.computedGeneric = computedGeneric;
+exports.createAdminDictSet = createAdminDictSet;
+exports.createSignatures = createSignatures;
 exports.createVerifierDictSet = createVerifierDictSet;
+exports.createVerifierDictSetFromEtherWallets = createVerifierDictSetFromEtherWallets;
+exports.createVerifierDictSetFromStrings = createVerifierDictSetFromStrings;
 exports.deepDecode = deepDecode;
 exports.deepDiff = deepDiff;
 exports.deserializeAddressList = deserializeAddressList;
@@ -7081,6 +7035,7 @@ exports.generateConstructorCode = generateConstructorCode;
 exports.generateDecodeClass = generateDecodeClass;
 exports.generateDeconstructorCode = generateDeconstructorCode;
 exports.generateEncodeClass = generateEncodeClass;
+exports.generateRandomVerifierSet = generateRandomVerifierSet;
 exports.generateSmlTestUtils = generateSmlTestUtils;
 exports.generateTonClassType = generateTonClassType;
 exports.generateUlnTestUtils = generateUlnTestUtils;
@@ -7088,6 +7043,7 @@ exports.getBocStringFromMessage = getBocStringFromMessage;
 exports.getCellName = getCellName;
 exports.getCellNameNumber = getCellNameNumber;
 exports.getClosestByteAlignedBits = getClosestByteAlignedBits;
+exports.getLzDict = getLzDict;
 exports.getMessageFromBocString = getMessageFromBocString;
 exports.getMsgPrices = getMsgPrices;
 exports.getOpcodeCRC = getOpcodeCRC;
@@ -7112,6 +7068,7 @@ exports.openAndDeployAllStoragesTemplate = openAndDeployAllStoragesTemplate;
 exports.orderConfigToCell = orderConfigToCell;
 exports.parseDirectory = parseDirectory;
 exports.parseTonAddress = parseTonAddress;
+exports.preprocessPublicKey = preprocessPublicKey;
 exports.printDeepDecode = printDeepDecode;
 exports.printDeepDiff = printDeepDiff;
 exports.printTransactionTrace = printTransactionTrace;
@@ -7133,6 +7090,7 @@ exports.serializePayees = serializePayees;
 exports.setLzTonSdkSaveToJson = setLzTonSdkSaveToJson;
 exports.setLzTonSdkWriteToConsole = setLzTonSdkWriteToConsole;
 exports.storageCollected = storageCollected;
+exports.stringPublicKeyToHash = stringPublicKeyToHash;
 exports.to32ByteBuffer = to32ByteBuffer;
 exports.toHaveTransactions = toHaveTransactions;
 exports.toPathArray = toPathArray;