@layerzerolabs/ton-sdk-tools 3.0.88 → 3.0.90-aptos-301.2

package/CHANGELOG.md

@@ -1,17 +1,5 @@
 # @layerzerolabs/ton-sdk-tools
 
-## 3.0.88
-
-### Patch Changes
-
-- d0cda5e: ton sdk-tools refactored, added rawDispatch action to funC++
-
-## 3.0.87
-
-### Patch Changes
-
-- e92c65d: Update initia.js version
-
 ## 3.0.86
 
 ### Patch Changes

package/dist/index.cjs

@@ -4,7 +4,6 @@ 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');
@@ -35,85 +34,15 @@ 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) {
@@ -121,46 +50,6 @@ 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");
 };
@@ -185,16 +74,6 @@ 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`;
@@ -466,11 +345,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, getLzDict } from '${baseWrapperImportPath}'
+import { ExtendedContract } from '${baseWrapperImportPath}'
 
 import { OPCODES } from '${opcodesImportPath}'
 
-import {
+import { getLzDict,
 ${allTypes.map((type) => "    " + type + ",\n").join("")}} from '${allTypesImportPath}'
 
 import { TonObjectUnwrapper } from '${tonObjectUnwrapperImportPath}'
@@ -667,7 +546,40 @@ import { Cell, OpenedContract, beginCell } from '@ton/core'
 import { SandboxContract } from '@ton/sandbox'
 
 import { TonContractWrapper } from '${tonContractWrapperImportPath}'
-import { ExtendedContract, LzDict, getLzDict } from '${baseWrapperImportPath}'
+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)
+}
 
 export interface Md {}
 
@@ -810,6 +722,7 @@ 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();
@@ -821,11 +734,11 @@ import { Cell, Transaction, TransactionComputeVm, TransactionDescriptionGeneric,
 import { BlockchainTransaction, EventMessageSent, SendMessageResult } from '@ton/sandbox'
 import { flattenTransaction } from '@ton/test-utils'
 
-import {
+import { getLzDict,
 ${allTypes.map((type) => "    " + type + ",\n").join("")}} from '${allTypesImportPath}'
 import { TonContractWrapper } from '${tonContractWrapperImportPath}'
 import { ClasslibWrapper } from '${classlibWrapperImportPath}'
-import { ExtendedContract, LzDict, getLzDict } from '${baseWrapperImportPath}'
+import { ExtendedContract } from '${baseWrapperImportPath}'
 
 export class TonObjectUnwrapper {
 ${Array.from(
@@ -1234,6 +1147,65 @@ 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;
@@ -1438,12 +1410,11 @@ import {
     ExtendedContract,
     sendMessageViaMultisigAndExpect,
     sendInternalMessageAndExpect,
-    LzDict,
-    toHaveTransactions,
-    addLibToBlockchain
+    toHaveTransactions
 } from '@layerzerolabs/ton-sdk-tools'
 
 import {
+    LzDict,
     LzEventHandler,
     MdPacketSent,
     OPCODES,
@@ -1480,6 +1451,10 @@ 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
@@ -1513,6 +1488,40 @@ 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))
 
@@ -2004,6 +2013,17 @@ 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(
@@ -3140,7 +3160,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, LzDict, createSignatures, createVerifierDictSetFromEtherWallets, generateRandomVerifierSet } from '@layerzerolabs/ton-sdk-tools'
+import { BlueprintArtfiact, ExtendedContract, Profile, addressToBigInt, cellFromArtifact, sendInternalMessageAndExpect, sendMessageViaMultisigAndExpect, } from '@layerzerolabs/ton-sdk-tools'
 
 import {
     OAppFixture,
@@ -3149,7 +3169,9 @@ import {
     SIGNATURE_BYTE_LENGTH,
     addMsgLibToController,
     createLzPacketFromPacketEncoded,
+    createVerifierDictSet,
     emptyObject,
+    generateRandomVerifierSet,
     protocolSetupGas,
     publicKeyToHash,
     requireDefined,
@@ -3159,6 +3181,7 @@ import {
 } from './auto-utils-common'
 
 import {
+    LzDict,
     LzEventHandler,
     MdPacketSent,
     OPCODES,
@@ -3741,7 +3764,7 @@ export async function openAndDeployDvnAndProxy(
                 admins: serializeAddressList(adminSet),
                 version: version,
                 quorum: 1n,
-                verifiers: createVerifierDictSetFromEtherWallets(verifierSet),
+                verifiers: await createVerifierDictSet(verifierSet, allStorages),
             })
         )
     )
@@ -4810,6 +4833,61 @@ 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 {
@@ -4833,7 +4911,7 @@ export async function signAndSendRequestToDvn({
 }: SignAndSendRequestToDvnParams): Promise<SendMessageResult> {
     const signedRequest = await allStorages.getNewMdSignedRequest({
         request,
-        signatures: createSignatures(request.hash(), verifierSet),
+        signatures: await createSignatures(request.hash(), verifierSet, allStorages),
     })
 
     return sendInternalMessageAndExpect({
@@ -5100,7 +5178,7 @@ export async function ulnVerifyAndExpect(
             opCode: OPCODES.Dvn_OP_VERIFY,
             md: await allStorages.getNewMdSignedRequest({
                 request: requestMd,
-                signatures: createSignatures(requestMd.hash(), verifiers),
+                signatures: await createSignatures(requestMd.hash(), verifiers, allStorages),
             }),
             expectedTransactions: [
                 {
@@ -6937,30 +7015,6 @@ 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;
@@ -6968,7 +7022,6 @@ 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;
@@ -6980,11 +7033,8 @@ 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;
@@ -7004,11 +7054,7 @@ 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;
@@ -7035,7 +7081,6 @@ exports.generateConstructorCode = generateConstructorCode;
 exports.generateDecodeClass = generateDecodeClass;
 exports.generateDeconstructorCode = generateDeconstructorCode;
 exports.generateEncodeClass = generateEncodeClass;
-exports.generateRandomVerifierSet = generateRandomVerifierSet;
 exports.generateSmlTestUtils = generateSmlTestUtils;
 exports.generateTonClassType = generateTonClassType;
 exports.generateUlnTestUtils = generateUlnTestUtils;
@@ -7043,7 +7088,6 @@ exports.getBocStringFromMessage = getBocStringFromMessage;
 exports.getCellName = getCellName;
 exports.getCellNameNumber = getCellNameNumber;
 exports.getClosestByteAlignedBits = getClosestByteAlignedBits;
-exports.getLzDict = getLzDict;
 exports.getMessageFromBocString = getMessageFromBocString;
 exports.getMsgPrices = getMsgPrices;
 exports.getOpcodeCRC = getOpcodeCRC;
@@ -7068,7 +7112,6 @@ exports.openAndDeployAllStoragesTemplate = openAndDeployAllStoragesTemplate;
 exports.orderConfigToCell = orderConfigToCell;
 exports.parseDirectory = parseDirectory;
 exports.parseTonAddress = parseTonAddress;
-exports.preprocessPublicKey = preprocessPublicKey;
 exports.printDeepDecode = printDeepDecode;
 exports.printDeepDiff = printDeepDiff;
 exports.printTransactionTrace = printTransactionTrace;
@@ -7090,7 +7133,6 @@ exports.serializePayees = serializePayees;
 exports.setLzTonSdkSaveToJson = setLzTonSdkSaveToJson;
 exports.setLzTonSdkWriteToConsole = setLzTonSdkWriteToConsole;
 exports.storageCollected = storageCollected;
-exports.stringPublicKeyToHash = stringPublicKeyToHash;
 exports.to32ByteBuffer = to32ByteBuffer;
 exports.toHaveTransactions = toHaveTransactions;
 exports.toPathArray = toPathArray;