@layerzerolabs/ton-sdk-tools 3.0.84 → 3.0.86

package/dist/index.cjs

@@ -3,11 +3,13 @@
 var fs = require('fs');
 var path = require('path');
 var core = require('@ton/core');
-var bigintBuffer = require('bigint-buffer');
 var crc32 = require('crc-32');
+var bigintBuffer = require('bigint-buffer');
 var Event = require('@ton/sandbox/dist/event/Event');
 var testUtils = require('@ton/test-utils');
 var sha256Js = require('@aws-crypto/sha256-js');
+var crypto = require('@ton/crypto');
+var ton = require('@ton/ton');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -32,43 +34,33 @@ var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var crc32__namespace = /*#__PURE__*/_interopNamespace(crc32);
 
 // src/sdk-tools.ts
-var cellFromArtifact = ({ hex }) => core.Cell.fromHex(hex);
-function getOpcodeCRC(input) {
-  return BigInt(crc32__namespace.str(input) >>> 0);
-}
 var MASTER_CHAIN_ID = -1;
 var BASE_CHAIN_ID = 0;
 var MASTER_CHAIN_SHARD = "8000000000000000";
-function bigintToAddress(value) {
-  const buf = to32ByteBuffer(value);
-  return core.Address.parse(`0:${buf.toString("hex")}`);
+var PUBLIC_KEY_BYTE_LENGTH = 64;
+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;
 }
-var addressToBigInt = (address) => {
-  return BigInt("0x" + address.hash.toString("hex"));
-};
-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));
+function createVerifierDictSet(verifiers) {
+  const verifierDict = core.Dictionary.empty(core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell());
+  for (const verifier of verifiers) {
+    verifierDict.set(publicKeyToHash(verifier), core.beginCell().endCell());
   }
-  const bf = bigintBuffer.toBufferBE(BigInt(value), maxIntermediateBufferSize);
-  return bf.subarray(-32);
+  return core.beginCell().storeDictDirect(verifierDict, core.Dictionary.Keys.BigUint(256), core.Dictionary.Values.Cell()).endCell();
 }
-function trim0x(str2) {
-  return str2.replace(/^0x/, "");
-}
-function isValidHex(str2) {
-  const hexRegex = /^(0x)?[0-9A-Fa-f]+$/;
-  return hexRegex.test(str2);
+var getBocStringFromMessage = (message) => {
+  return core.beginCell().store(core.storeMessageRelaxed(message)).endCell().toBoc().toString("base64");
+};
+var getMessageFromBocString = (bocString) => {
+  const cell = core.Cell.fromBase64(bocString);
+  const cellSlice = cell.beginParse();
+  return core.loadMessageRelaxed(cellSlice);
+};
+var cellFromArtifact = ({ hex }) => core.Cell.fromHex(hex);
+function getOpcodeCRC(input) {
+  return BigInt(crc32__namespace.str(input) >>> 0);
 }
 function findDeepestCell(cell) {
   const refs = Array.from({ length: cell.refs.length }, (_, i) => cell.refs.at(i));
@@ -1143,7 +1135,8 @@ function saveViewFunctions(viewFunctions, directory, filename) {
   const generated = [
     file_signature_header,
     `import { Address, Cell, Tuple, TupleItem, beginCell } from '@ton/core'`,
-    `import { ExtendedContract, TonContractWrapper } from '../wrappers'`,
+    `import { TonContractWrapper } from '../wrappers'`,
+    `import { ExtendedContract } from '@layerzerolabs/ton-sdk-tools'`,
     ""
   ];
   for (const [contractName, functions] of Object.entries(viewFunctions)) {
@@ -1154,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;
@@ -3103,11 +3155,12 @@ import ExecutorArtifact from '@layerzerolabs/layerzero-v2-ton/build/Executor.com
 import ExecutorFeelibArtifact from '@layerzerolabs/layerzero-v2-ton/build/ExecutorFeeLib.compiled.json'
 import PriceFeedCacheArtifact from '@layerzerolabs/layerzero-v2-ton/build/PriceFeedCache.compiled.json'
 import PriceFeedFeeLibDefaultArtifact from '@layerzerolabs/layerzero-v2-ton/build/PriceFeedFeeLibDefault.compiled.json'
+import MaliciousFeeLibArtifact from '@layerzerolabs/layerzero-v2-ton/build/MaliciousFeeLib.compiled.json'
 import ProxyArtifact from '@layerzerolabs/layerzero-v2-ton/build/Proxy.compiled.json'
 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 { ExtendedContract, Profile, addressToBigInt, cellFromArtifact, sendInternalMessageAndExpect, sendMessageViaMultisigAndExpect, } from '@layerzerolabs/ton-sdk-tools'
+import { BlueprintArtfiact, ExtendedContract, Profile, addressToBigInt, cellFromArtifact, sendInternalMessageAndExpect, sendMessageViaMultisigAndExpect, } from '@layerzerolabs/ton-sdk-tools'
 
 import {
     OAppFixture,
@@ -3347,19 +3400,26 @@ export async function addDvnWorkers(
     receiveDvnFixtures: DvnFixture[],
     dstEid: bigint,
     priceFeedCacheAddress: Address,
-    eventHandler: LzEventHandler
+    eventHandler: LzEventHandler,
+    addMaliciousWorker = false
 ): Promise<void> {
     requireDefined(sendDvnFixtures)
     requireDefined(receiveDvnFixtures)
     const msglib = uln.get(dstEid)
     requireDefined(msglib)
+    let feelibArtifact: BlueprintArtfiact
+    if (addMaliciousWorker) {
+        feelibArtifact = MaliciousFeeLibArtifact
+    } else {
+        feelibArtifact = DvnFeelibArtifact
+    }
     for (const dvnFixture of [...sendDvnFixtures, ...receiveDvnFixtures]) {
         const dvnWorkerCallMd = await allStorages.getNewMdExecuteParams({
             target: addressToBigInt(msglibManager.address),
             forwardingAddress: 0n,
             callData: await allStorages.getNewUlnWorkerFeelibInfo({
                 workerAddress: addressToBigInt(dvnFixture.dvn.address),
-                workerFeelibBytecode: cellFromArtifact(DvnFeelibArtifact),
+                workerFeelibBytecode: cellFromArtifact(feelibArtifact),
                 workerFeelibStorage: await allStorages.getNewDvnFeelib({
                     quorum: BigInt(0),
                     remoteGas: BigInt(0),
@@ -3932,6 +3992,18 @@ export async function deployConfigAndRegisterUln(
     )
     await eventHandler.addCurrentEventsToAllEvents(internalMsgResults, srcFixture.msglibManager)
 
+    // ===================================registerUlnWorkerInfo - maliciousFeeLib=======================================
+
+    internalMsgResults = await registerUlnWorkerInfo(
+        blockchain,
+        multiSigners,
+        srcFixture,
+        await allStorages.getNewMdUlnWorkerFeelibBytecode({
+            bytecode: cellFromArtifact(MaliciousFeeLibArtifact),
+        })
+    )
+    await eventHandler.addCurrentEventsToAllEvents(internalMsgResults, srcFixture.msglibManager)
+
     // ============================registerUlnWorkerInfo - executorFeeLib=======================================
 
     internalMsgResults = await registerUlnWorkerInfo(
@@ -6207,6 +6279,742 @@ async function openAndDeployAllStoragesTemplate(blockchain, deployer, artifact,
   });
   return allStorages;
 }
+function toPathArray(path4) {
+  if (!/^[mM]'?/.test(path4)) {
+    throw new Error('Path must start with "m" or "M"');
+  }
+  const parts = path4.replace(/^[mM]'?\//, "").split("/");
+  const ret = Array(parts.length);
+  for (let i = 0; i < parts.length; i++) {
+    const tmp = /^(\d{1,10})[hH']$/.exec(parts[i]);
+    if (tmp === null) {
+      throw new Error("Invalid input");
+    }
+    ret[i] = parseInt(tmp[1], 10);
+    if (ret[i] >= 2147483648) {
+      throw new Error("Invalid child index");
+    }
+  }
+  return ret;
+}
+async function getTonWalletFromMnemonic(mnemonic, path4 = "m/44'/607'/0'/0'/0'", workchain = 0) {
+  const seed = await crypto.mnemonicToHDSeed(mnemonic.split(" "));
+  const indices = toPathArray(path4);
+  const derivedSeed = await crypto.deriveEd25519Path(seed, indices);
+  const keyPair = crypto.keyPairFromSeed(derivedSeed);
+  return {
+    wallet: ton.WalletContractV4.create({
+      publicKey: keyPair.publicKey,
+      workchain
+    }),
+    keyPair
+  };
+}
+var getTonWalletFromMnemonicLegacy = async (mnemonic, workchain = 0) => {
+  const key = await crypto.mnemonicToWalletKey(mnemonic.split(" "));
+  const wallet = ton.WalletContractV4.create({
+    publicKey: key.publicKey,
+    workchain
+  });
+  return { wallet, keyPair: key };
+};
+var hexToCells = (hex) => {
+  const bitString = new core.BitString(Buffer.from(trim0x(hex), "hex"), 0, hex.slice(2).length * 4);
+  const cells = [];
+  let offset = 0;
+  while (offset < bitString.length) {
+    cells.push(core.beginCell());
+    cells[cells.length - 1].storeBits(
+      bitString.substring(offset, Math.min(bitString.length - offset, MAX_CELL_BITS))
+    );
+    offset += MAX_CELL_BITS;
+  }
+  if (cells.length === 0) {
+    return core.beginCell().asCell();
+  }
+  cells.reverse();
+  return cells.slice(1).reduce((children, parent) => parent.storeRef(children), cells[0]).asCell();
+};
+var getTotalBits = (cell) => {
+  const parser = cell.beginParse();
+  return parser.remainingBits + (parser.remainingRefs > 0 ? getTotalBits(parser.loadRef()) : 0);
+};
+var getClosestByteAlignedBits = (bits) => {
+  return Math.ceil(bits / 8) * 8;
+};
+var cellsToHex = (cell) => {
+  let parser = cell.beginParse();
+  const totalBits = getClosestByteAlignedBits(getTotalBits(cell));
+  const bitBuilder = new core.BitBuilder(totalBits);
+  while (parser.remainingRefs >= 0) {
+    const bitsString = parser.loadBits(parser.remainingBits);
+    bitBuilder.writeBits(bitsString);
+    if (parser.remainingRefs === 0) {
+      break;
+    }
+    parser = parser.loadRef().beginParse();
+  }
+  return `0x${bitBuilder.buffer().toString("hex")}`;
+};
+var calculateCellConsumption = (cell) => {
+  let parser = cell.beginParse();
+  let numberOfCells = 1;
+  let bits = parser.remainingBits;
+  while (parser.remainingRefs > 0) {
+    parser = parser.loadRef().beginParse();
+    numberOfCells++;
+    bits += parser.remainingBits;
+  }
+  return { numberOfCells, bits };
+};
+var calculateCellConsumptionFromHex = (hex) => {
+  return calculateCellConsumption(hexToCells(hex));
+};
+
+// src/common-ton/src/class/generators.ts
+var baseObjects = {
+  POOO: {
+    "0": {
+      fieldName: "POOO::nextEmpty",
+      fieldType: "cl::t::uint64"
+    },
+    "1": {
+      fieldName: "POOO::bitmap",
+      fieldType: "cl::t::cellRef"
+    },
+    name: "POOO"
+  },
+  BaseStorage: {
+    "0": {
+      fieldName: "BaseStorage::owner",
+      fieldType: "cl::t::address"
+    },
+    "1": {
+      fieldName: "BaseStorage::authenticated",
+      fieldType: "cl::t::bool"
+    },
+    "2": {
+      fieldName: "BaseStorage::initialized",
+      fieldType: "cl::t::bool"
+    },
+    "3": {
+      fieldName: "BaseStorage::initialStorage",
+      fieldType: "cl::t::cellRef"
+    },
+    name: "baseStore"
+  },
+  "action::event": {
+    "0": {
+      fieldName: "action::event::topic",
+      fieldType: "cl::t::uint256"
+    },
+    "1": {
+      fieldName: "action::event::body",
+      fieldType: "cl::t::objRef"
+    },
+    "2": {
+      fieldName: "action::event::initialStorage",
+      fieldType: "cl::t::objRef"
+    },
+    name: "event"
+  }
+};
+var fieldTypes = [
+  "cl::t::uint1",
+  // 1 bit
+  "cl::t::bool",
+  // 1 bit
+  "cl::t::uint2",
+  // 2 bits
+  "cl::t::uint4",
+  // 4 bits
+  "cl::t::uint8",
+  // 8 bits
+  "cl::t::uint16",
+  // 16 bits
+  "cl::t::uint32",
+  // 32 bits
+  "cl::t::uint64",
+  // 64 bits
+  "cl::t::uint128",
+  // 128 bits
+  "cl::t::coins",
+  // 128 bits
+  "cl::t::uint256",
+  // 256 bits
+  "cl::t::address",
+  // 256 bits
+  "cl::t::dict256",
+  // cell
+  "cl::t::cellRef",
+  // cell
+  "cl::t::objRef",
+  // cell
+  "cl::t::addressList"
+  // cell
+];
+var isClassName = (_tonObjects, fieldType) => {
+  return fieldType in _tonObjects;
+};
+var getClassNameAndDefinition = (_tonObjects) => (_className) => {
+  let className = _className;
+  let classDefinition = _tonObjects[className];
+  if (!(className in _tonObjects)) {
+    [className, classDefinition] = Object.entries(_tonObjects).find(
+      ([_, value]) => value.name === className
+    );
+    throw new Error(`Class ${className} not found`);
+  }
+  return { className, classDefinition };
+};
+var generateEncodeClass = (_tonObjects) => (_className, fields) => {
+  const { className, classDefinition } = getClassNameAndDefinition(_tonObjects)(_className);
+  const fieldsArray = Object.entries(classDefinition).filter(([_, field]) => typeof field !== "string");
+  const results = Object.entries(fields).map(([fieldName, fieldValue]) => {
+    const [index, field] = fieldsArray.find(
+      ([_, field2]) => field2.fieldName === `${className}::${fieldName}`
+    );
+    if (field.fieldType === "cl::t::dict256" && !(fieldValue instanceof core.Cell)) {
+      return [
+        Number(index),
+        cl.t.objRef,
+        fieldValue.rawCell ?? core.beginCell().storeDict(fieldValue).endCell().asSlice().loadRef()
+      ];
+    }
+    if (field.fieldType === "cl::t::addressList" && !(fieldValue instanceof core.Cell)) {
+      return [
+        Number(index),
+        cl.t.objRef,
+        serializeAddressList(fieldValue)
+      ];
+    }
+    if (isClassName(_tonObjects, field.fieldType) && !(fieldValue instanceof core.Cell)) {
+      return [
+        Number(index),
+        cl.t.objRef,
+        generateEncodeClass(_tonObjects)(
+          field.fieldType,
+          fieldValue
+        )
+      ];
+    }
+    const typeMetadata = field.fieldType.split("cl::t::")[1];
+    let tNumber;
+    if (typeMetadata in cl.t) {
+      tNumber = cl.t[typeMetadata];
+    } else {
+      tNumber = cl.t.objRef;
+    }
+    return [Number(index), tNumber, fieldValue, typeMetadata];
+  }).sort(([a], [b]) => a - b).map(([_, type, value, typeMetadata]) => ({
+    type,
+    value,
+    typeMetadata
+  }));
+  return clDeclare(asciiStringToBigint2(_tonObjects[className].name), results);
+};
+var generateDecodeClass = (_tonObjects) => (_className, cell) => {
+  const { className, classDefinition } = getClassNameAndDefinition(_tonObjects)(_className);
+  const enhanceCell = (cell2) => {
+    return new Proxy(cell2, {
+      get(target, prop) {
+        if (prop === "getAddressList") {
+          return () => enhanceAddressList(cell2);
+        }
+        if (prop === "cellsToHex") {
+          return () => cellsToHex(cell2);
+        }
+        if (prop === "getDict") {
+          return enhancedLoadDict(cell2).getDict;
+        }
+        if (prop === "decode") {
+          return (className2) => generateDecodeClass(_tonObjects)(className2, cell2);
+        }
+        if (prop === "clGetCellRef") {
+          return (index) => enhanceCell(clGetCellRef(cell2, index));
+        }
+        if (prop === "clGetUint") {
+          return (index, width) => clGetUint(cell2, index, width);
+        }
+        if (prop === "getCellName") {
+          return () => getCellName(cell2);
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+  };
+  const injectRawCell = (value, rawCell) => {
+    return new Proxy(value, {
+      get(target, prop) {
+        if (prop === "rawCell") {
+          return enhanceCell(rawCell);
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+  };
+  const enhanceAddress = (address) => {
+    return new Proxy(bigintToAddress(address), {
+      get(target, prop) {
+        if (prop === "toHex") {
+          return () => bigIntToHex(address);
+        }
+        if (prop === "toBigInt") {
+          return () => address;
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+  };
+  const enhanceAddressList = (rawCell) => {
+    const addressList = deserializeAddressList(rawCell).map(enhanceAddress);
+    return injectRawCell(
+      new Proxy(addressList, {
+        get(target, prop) {
+          if (prop === "toHex") {
+            return () => addressList.map((address) => address.toHex());
+          }
+          if (prop === "toBigInt") {
+            return () => addressList.map((address) => address.toBigInt());
+          }
+          return Reflect.get(target, prop);
+        }
+      }),
+      rawCell
+    );
+  };
+  const enhancedLoadDict = (rawCell) => {
+    return {
+      getDict: (value) => {
+        return rawCell.bits.length === 0 ? core.Dictionary.empty(core.Dictionary.Keys.BigUint(256), value) : rawCell.beginParse().loadDictDirect(core.Dictionary.Keys.BigUint(256), value);
+      },
+      rawCell: enhanceCell(rawCell)
+    };
+  };
+  return Object.fromEntries(
+    Object.entries(classDefinition).filter(([_, field]) => typeof field !== "string").map(([index, field]) => {
+      const tNumber = cl.t[field.fieldType.split("cl::t::")[1]];
+      const fieldName = field.fieldName.split(`${className}::`)[1];
+      if (field.fieldType in _tonObjects) {
+        const rawCell = clGetCellRef(cell, Number(index));
+        if (field.fieldType === baseObjects.POOO.name && emptyCell().hash().equals(rawCell.hash())) {
+          return [
+            fieldName,
+            new Proxy(emptyPOOO(), {
+              get(target, prop) {
+                if (prop === "rawCell") {
+                  return enhanceCell(rawCell);
+                }
+                return Reflect.get(target, prop);
+              }
+            })
+          ];
+        }
+        return [
+          fieldName,
+          new Proxy(
+            generateDecodeClass(_tonObjects)(field.fieldType, clGetCellRef(cell, Number(index))),
+            {
+              get(target, prop) {
+                if (prop === "rawCell") {
+                  return enhanceCell(rawCell);
+                }
+                return Reflect.get(target, prop);
+              }
+            }
+          )
+        ];
+      }
+      if (field.fieldType === "cl::t::addressList") {
+        const rawCell = clGetCellRef(cell, Number(index));
+        return [fieldName, enhanceAddressList(rawCell)];
+      }
+      if (field.fieldType === "cl::t::dict256") {
+        return [fieldName, enhancedLoadDict(clGetCellRef(cell, Number(index)))];
+      }
+      if (tNumber === cl.t.objRef) {
+        return [fieldName, enhanceCell(clGetCellRef(cell, Number(index)))];
+      }
+      if (field.fieldType === "cl::t::address") {
+        return [fieldName, enhanceAddress(clGetUint(cell, Number(index), _getTypeWidth(tNumber)))];
+      }
+      if (field.fieldType === "cl::t::bool") {
+        return [fieldName, clGetUint(cell, Number(index), _getTypeWidth(tNumber)) === 1n];
+      }
+      return [fieldName, clGetUint(cell, Number(index), _getTypeWidth(tNumber))];
+    })
+  );
+};
+var baseEncodeClass = generateEncodeClass(baseObjects);
+var baseDecodeClass = generateDecodeClass(baseObjects);
+
+// src/common-ton/src/class/helpers.ts
+var asciiStringToBigint2 = (target) => {
+  return BigInt(`0x${Buffer.from(target).toString("hex")}`);
+};
+var bigintToAsciiString = (target) => {
+  return Buffer.from(target.toString(16), "hex").toString("ascii");
+};
+var getCellNameNumber = (cell) => {
+  const slice = cell.beginParse();
+  const name = slice.loadUintBig(NAME_WIDTH);
+  return name;
+};
+var getCellName = (cell) => {
+  const nameNumber = getCellNameNumber(cell);
+  return bigintToAsciiString(nameNumber);
+};
+var emptyCell = () => {
+  return core.beginCell().asCell();
+};
+var nullObject = () => {
+  return emptyCell();
+};
+var emptyMap = () => {
+  return emptyCell();
+};
+var emptyPOOO = () => {
+  return baseEncodeClass("POOO", {
+    nextEmpty: 1,
+    bitmap: (() => {
+      const builder = new core.BitBuilder(MAX_CELL_BITS);
+      builder.writeUint(0, 1023);
+      const bitString = builder.build();
+      const bitReader = new core.BitReader(bitString);
+      const slice = new core.Slice(bitReader, []);
+      return slice.asCell();
+    })()
+  });
+};
+var initBaseStorage = (owner) => {
+  return baseEncodeClass("BaseStorage", {
+    owner,
+    authenticated: false,
+    initialized: false,
+    initialStorage: emptyCell()
+  });
+};
+function serializeAddressList(addresses) {
+  if (addresses instanceof core.Cell) {
+    return addresses;
+  }
+  const addressListBuilder = [core.beginCell()];
+  for (let idx = 0; idx < addresses.length; idx++) {
+    if (addressListBuilder[addressListBuilder.length - 1].availableBits < 256) {
+      addressListBuilder.push(core.beginCell());
+    }
+    addressListBuilder[addressListBuilder.length - 1].storeUint(addressToBigInt(addresses[idx]), 256);
+  }
+  let resultCell = addressListBuilder.pop().endCell();
+  while (addressListBuilder.length > 0) {
+    const head = addressListBuilder.pop();
+    resultCell = head.storeRef(resultCell).endCell();
+  }
+  return resultCell;
+}
+function deserializeAddressList(cell) {
+  const addresses = [];
+  let currentCell = cell;
+  while (currentCell) {
+    const slice = currentCell.beginParse();
+    while (slice.remainingBits >= 256) {
+      addresses.push(slice.loadUintBig(256));
+    }
+    currentCell = slice.remainingRefs > 0 ? slice.loadRef() : null;
+  }
+  return addresses;
+}
+function serializePayees(payeesInfo) {
+  const numPayees = payeesInfo.length;
+  if (numPayees === 0) {
+    return emptyCell();
+  }
+  let linkedList = core.beginCell();
+  let idx = 1;
+  while (idx <= numPayees) {
+    const curPayee = payeesInfo[numPayees - idx];
+    if (idx % 3 === 0) {
+      linkedList = core.beginCell().storeRef(linkedList.endCell()).storeUint(addressToBigInt(curPayee.address), 256).storeUint(BigInt(curPayee.amount), 64);
+    } else {
+      linkedList = linkedList.storeUint(addressToBigInt(curPayee.address), 256).storeUint(BigInt(curPayee.amount), 64);
+    }
+    idx += 1;
+  }
+  return linkedList.endCell();
+}
+function deserializePayees(serializedPayees) {
+  let payeesSlice = serializedPayees.beginParse();
+  if (payeesSlice.remainingBits === 0) {
+    return [];
+  }
+  const payees = [];
+  const payeeBits = 256 + 64;
+  while (payeesSlice.remainingBits >= payeeBits || payeesSlice.remainingRefs > 0) {
+    if (payeesSlice.remainingBits >= payeeBits) {
+      payees.push({
+        address: addressToHex(payeesSlice.loadUintBig(256)),
+        amount: payeesSlice.loadUintBig(64)
+      });
+    } else if (payeesSlice.remainingRefs > 0) {
+      payeesSlice = payeesSlice.loadRef().beginParse();
+    } else {
+      break;
+    }
+  }
+  return payees;
+}
+
+// src/common-ton/src/class/class.ts
+var cl = {
+  t: {
+    uint1: 0,
+    bool: 0,
+    // same as uint1
+    uint2: 1,
+    uint4: 2,
+    uint8: 3,
+    uint16: 4,
+    uint32: 5,
+    uint64: 6,
+    uint128: 7,
+    coins: 7,
+    // same as uint128
+    uint256: 8,
+    address: 8,
+    // same as uint256
+    cellRef: 9,
+    // same as cellRef
+    dict256: 9,
+    // same as cellRef
+    objRef: 9,
+    // same as cellRef
+    addressList: 9
+    // same as cellRef
+  },
+  NULL_CLASS_NAME: "NULL",
+  ERROR: {
+    INVALID_CLASS: "INVALID_CLASS"
+  }
+};
+var MAX_NAME_LEN = 10;
+var NAME_WIDTH = 8 * MAX_NAME_LEN;
+var FIELD_TYPE_WIDTH = 4;
+var CELL_ID_WIDTH = 2;
+var DATA_OFFSET_WIDTH = 10;
+var REF_OFFSET_WIDTH = 2;
+var FIELD_INFO_WIDTH = FIELD_TYPE_WIDTH + CELL_ID_WIDTH + DATA_OFFSET_WIDTH + REF_OFFSET_WIDTH;
+var MAX_CLASS_FIELDS = 15;
+var BASIC_HEADER_WIDTH = NAME_WIDTH;
+var HEADER_WIDTH = BASIC_HEADER_WIDTH + MAX_CLASS_FIELDS * FIELD_INFO_WIDTH;
+var MAX_CELL_BITS = 1023;
+var MAX_CELL_REFS = 4;
+var numberTypeLikeToAbsBigInt = (val, typeMetadata) => {
+  if (val instanceof core.Address) {
+    return addressToBigInt(val);
+  }
+  if (typeof val === "string") {
+    if (core.Address.isFriendly(val) || core.Address.isRaw(val)) {
+      return addressToBigInt(core.Address.parse(val));
+    }
+    if (typeMetadata === "address") {
+      try {
+        return BigInt("0x0" + val.substring(2));
+      } catch {
+      }
+    }
+  }
+  const _val = BigInt(val);
+  if (_val < -1n) {
+    throw new Error("Invalid value. Only accepted negative value is -1");
+  }
+  return _val < 0 ? -_val : _val;
+};
+var _getTypeWidth = (clType) => {
+  if (clType <= cl.t.uint256) {
+    return 1 << clType;
+  }
+  return 0;
+};
+var isNumericType = (field) => {
+  return field.type <= cl.t.uint256;
+};
+var isCellType = (field) => {
+  return field.type == cl.t.cellRef;
+};
+var clDeclare = (name, fields) => {
+  if (fields.length > MAX_CLASS_FIELDS) {
+    throw new Error(cl.ERROR.INVALID_CLASS);
+  }
+  const classBuilder = [null, core.beginCell()];
+  let headerBuilder = core.beginCell().storeUint(name, NAME_WIDTH);
+  let curDataCell = 1;
+  let curRefCell = 1;
+  let curCellMaxRefs = 2;
+  let curDataOffset = HEADER_WIDTH;
+  let curRefOffset = 0;
+  for (const field of fields) {
+    const fieldBits = _getTypeWidth(field.type);
+    if (curDataOffset + fieldBits > MAX_CELL_BITS) {
+      curDataCell += 1;
+      curDataOffset = 0;
+      if (curDataCell >= classBuilder.length) {
+        classBuilder.push(core.beginCell());
+      }
+    }
+    if (fieldBits == 0) {
+      if (curRefOffset + 1 > curCellMaxRefs) {
+        curRefCell += 1;
+        curRefOffset = 0;
+        curCellMaxRefs = MAX_CELL_REFS;
+        if (curRefCell >= classBuilder.length) {
+          classBuilder.push(core.beginCell());
+        }
+      }
+    }
+    if (isNumericType(field)) {
+      classBuilder[curDataCell] = classBuilder[curDataCell].storeUint(
+        numberTypeLikeToAbsBigInt(field.value, field.typeMetadata),
+        fieldBits
+      );
+    } else if (isCellType(field)) {
+      classBuilder[curRefCell] = classBuilder[curRefCell].storeRef(field.value);
+    } else {
+      throw new Error(cl.ERROR.INVALID_CLASS);
+    }
+    headerBuilder = headerBuilder.storeUint(field.type, FIELD_TYPE_WIDTH);
+    if (fieldBits > 0) {
+      headerBuilder = headerBuilder.storeUint(curDataCell == 1 ? 0 : curDataCell, CELL_ID_WIDTH).storeUint(curDataOffset, DATA_OFFSET_WIDTH).storeUint(3, REF_OFFSET_WIDTH);
+      curDataOffset += fieldBits;
+    } else {
+      headerBuilder = headerBuilder.storeUint(curRefCell == 1 ? 0 : curRefCell, CELL_ID_WIDTH).storeUint(MAX_CELL_BITS, DATA_OFFSET_WIDTH).storeUint(curRefOffset, REF_OFFSET_WIDTH);
+      curRefOffset += 1;
+    }
+  }
+  let rootBuilder = classBuilder[1];
+  const numCells = classBuilder.length - 1;
+  if (numCells > 1) {
+    if (rootBuilder.refs == 0) {
+      rootBuilder = rootBuilder.storeRef(emptyCell()).storeRef(emptyCell());
+    } else if (rootBuilder.refs == 1) {
+      rootBuilder = rootBuilder.storeRef(emptyCell());
+    }
+  }
+  const trailingOnes = HEADER_WIDTH - headerBuilder.bits;
+  headerBuilder = headerBuilder.storeBits(new core.BitString(Buffer.from("F".repeat(trailingOnes), "hex"), 0, trailingOnes)).storeBuilder(rootBuilder);
+  if (numCells == 1) {
+    return headerBuilder.endCell();
+  }
+  if (numCells == 2) {
+    return headerBuilder.storeRef(classBuilder[2].endCell()).endCell();
+  }
+  return headerBuilder.storeRef(classBuilder[2].endCell()).storeRef(classBuilder[3].endCell()).endCell();
+};
+var loadFieldInfo = (cell, fieldName) => {
+  const headerSlice = cell.beginParse();
+  const fieldInfoOffset = BASIC_HEADER_WIDTH + fieldName * FIELD_INFO_WIDTH;
+  headerSlice.skip(fieldInfoOffset + FIELD_TYPE_WIDTH);
+  const fieldCellIndex = headerSlice.loadUint(CELL_ID_WIDTH);
+  const fieldOffset = headerSlice.loadUint(DATA_OFFSET_WIDTH);
+  const fieldRefIdx = headerSlice.loadUint(REF_OFFSET_WIDTH);
+  return { fieldCellIndex, fieldOffset, fieldRefIdx };
+};
+var clGetUint = (cell, fieldName, width) => {
+  const headerSlice = cell.beginParse();
+  const { fieldCellIndex, fieldOffset } = loadFieldInfo(cell, fieldName);
+  if (fieldCellIndex == 0) {
+    return headerSlice.skip(fieldOffset).loadUintBig(width);
+  }
+  for (let i = 0; i < fieldCellIndex; i++) {
+    headerSlice.loadRef();
+  }
+  return headerSlice.loadRef().beginParse().skip(fieldOffset).loadUintBig(width);
+};
+var clGetCellRef = (cell, fieldName) => {
+  const headerSlice = cell.beginParse();
+  const { fieldCellIndex, fieldRefIdx } = loadFieldInfo(cell, fieldName);
+  if (fieldCellIndex == 0) {
+    for (let i = 0; i < fieldRefIdx; i++) {
+      headerSlice.loadRef();
+    }
+    return headerSlice.loadRef();
+  }
+  for (let i = 0; i < fieldCellIndex; i++) {
+    headerSlice.loadRef();
+  }
+  const cellRef = headerSlice.loadRef().beginParse();
+  for (let i = 0; i < fieldRefIdx; i++) {
+    cellRef.loadRef();
+  }
+  return cellRef.loadRef();
+};
+var deepDecode = (decodeClass, cell, hashUndecodeable) => {
+  if (!(cell instanceof core.Cell)) {
+    return cell;
+  }
+  try {
+    const decoded = decodeClass(getCellName(cell), cell);
+    return Object.fromEntries(
+      //cell was decoded successfully, recurse
+      Object.entries(decoded).map(([k, v]) => [
+        k,
+        deepDecode(decodeClass, v, hashUndecodeable)
+      ])
+    );
+  } catch (e) {
+    return hashUndecodeable === true ? cell.hash().toString("hex") : cell;
+  }
+};
+var printDeepDecode = (decodeClass, cell) => {
+  console.log(
+    JSON.stringify(
+      deepDecode(decodeClass, cell, true),
+      (_, v) => {
+        if (typeof v === "bigint") {
+          return v.toString();
+        }
+        if (v instanceof core.Address) {
+          return addressToHex(v);
+        }
+        return v;
+      },
+      2
+    )
+  );
+};
+
+// src/common-ton/src/deepDiffCells.ts
+var diffRecurse = (cellA, cellB, ancestry) => {
+  if (cellA === cellB) {
+    return [];
+  }
+  if (typeof cellA !== "object" || typeof cellB !== "object") {
+    return [{ a: cellA, b: cellB, ancestry }];
+  }
+  const cellAKeysSet = new Set(Object.keys(cellA));
+  return [
+    ...Object.keys(cellA).map(
+      (cellAKey) => diffRecurse(cellA[cellAKey], cellB[cellAKey], ancestry.concat(cellAKey))
+    ),
+    ...Object.keys(cellB).filter((k) => !cellAKeysSet.has(k)).map((cellBKey) => {
+      return diffRecurse(cellA[cellBKey], cellB[cellBKey], ancestry.concat(cellBKey));
+    })
+  ].flat();
+};
+var deepDiff = (decodeClass, cellA, cellB) => {
+  const decodedA = deepDecode(decodeClass, cellA, true);
+  const decodedB = deepDecode(decodeClass, cellB, true);
+  const recursed = diffRecurse(decodedA, decodedB, ["diff_root"]);
+  return { isEqual: recursed.length === 0, inequalValues: recursed };
+};
+var printDeepDiff = (decodeClass, cellA, cellB) => {
+  console.log(
+    JSON.stringify(
+      deepDiff(decodeClass, cellA, cellB),
+      (_, v) => typeof v === "bigint" ? v.toString() : v,
+      2
+    )
+  );
+};
 
 exports.BASE_CHAIN_ID = BASE_CHAIN_ID;
 exports.BaseWrapper = BaseWrapper;
@@ -6216,24 +7024,51 @@ exports.JettonMinter = JettonMinter;
 exports.JettonWallet = JettonWallet;
 exports.MASTER_CHAIN_ID = MASTER_CHAIN_ID;
 exports.MASTER_CHAIN_SHARD = MASTER_CHAIN_SHARD;
+exports.MAX_CELL_BITS = MAX_CELL_BITS;
 exports.MultiSigErrors = MultiSigErrors;
 exports.MultiSigOpCodes = MultiSigOpCodes;
 exports.MultiSigParams = MultiSigParams;
 exports.Multisig = Multisig;
+exports.NAME_WIDTH = NAME_WIDTH;
 exports.Op = Op;
 exports.Order = Order;
+exports.PUBLIC_KEY_BYTE_LENGTH = PUBLIC_KEY_BYTE_LENGTH;
 exports.Txiterator = Txiterator;
+exports._getTypeWidth = _getTypeWidth;
 exports.addressToBigInt = addressToBigInt;
+exports.addressToHex = addressToHex;
+exports.asciiStringToBigint = asciiStringToBigint2;
+exports.baseDecodeClass = baseDecodeClass;
+exports.baseEncodeClass = baseEncodeClass;
+exports.bigIntToHex = bigIntToHex;
 exports.bigintToAddress = bigintToAddress;
+exports.bigintToAsciiString = bigintToAsciiString;
 exports.buildOnchainMetadata = buildOnchainMetadata;
+exports.calculateCellConsumption = calculateCellConsumption;
+exports.calculateCellConsumptionFromHex = calculateCellConsumptionFromHex;
 exports.cellFromArtifact = cellFromArtifact;
+exports.cellsToHex = cellsToHex;
+exports.cl = cl;
+exports.clDeclare = clDeclare;
+exports.clGetCellRef = clGetCellRef;
+exports.clGetUint = clGetUint;
+exports.compareAddresses = compareAddresses;
 exports.computedGeneric = computedGeneric;
+exports.createVerifierDictSet = createVerifierDictSet;
+exports.deepDecode = deepDecode;
+exports.deepDiff = deepDiff;
+exports.deserializeAddressList = deserializeAddressList;
+exports.deserializePayees = deserializePayees;
 exports.differentAddress = differentAddress;
+exports.emptyCell = emptyCell;
+exports.emptyMap = emptyMap;
+exports.emptyPOOO = emptyPOOO;
 exports.executeFrom = executeFrom;
 exports.executeTill = executeTill;
 exports.extractErrors = extractErrors;
 exports.extractEvents = extractEvents;
 exports.extractOpcodes = extractOpcodes;
+exports.fieldTypes = fieldTypes;
 exports.findDeepestCell = findDeepestCell;
 exports.findTransaction = findTransaction;
 exports.formatCoinsPure = formatCoinsPure;
@@ -6243,25 +7078,44 @@ exports.generateAllTonClassTypes = generateAllTonClassTypes;
 exports.generateAllViewFunctions = generateAllViewFunctions;
 exports.generateCommonTestUtils = generateCommonTestUtils;
 exports.generateConstructorCode = generateConstructorCode;
+exports.generateDecodeClass = generateDecodeClass;
 exports.generateDeconstructorCode = generateDeconstructorCode;
+exports.generateEncodeClass = generateEncodeClass;
 exports.generateSmlTestUtils = generateSmlTestUtils;
 exports.generateTonClassType = generateTonClassType;
 exports.generateUlnTestUtils = generateUlnTestUtils;
+exports.getBocStringFromMessage = getBocStringFromMessage;
+exports.getCellName = getCellName;
+exports.getCellNameNumber = getCellNameNumber;
+exports.getClosestByteAlignedBits = getClosestByteAlignedBits;
+exports.getMessageFromBocString = getMessageFromBocString;
 exports.getMsgPrices = getMsgPrices;
 exports.getOpcodeCRC = getOpcodeCRC;
 exports.getRandom = getRandom;
 exports.getRandomInt = getRandomInt;
 exports.getSpecificFiles = getSpecificFiles;
+exports.getTonWalletFromMnemonic = getTonWalletFromMnemonic;
+exports.getTonWalletFromMnemonicLegacy = getTonWalletFromMnemonicLegacy;
+exports.getTotalBits = getTotalBits;
+exports.hexToCells = hexToCells;
+exports.initBaseStorage = initBaseStorage;
+exports.isClassName = isClassName;
 exports.jettonContentToCell = jettonContentToCell;
 exports.jettonMinterConfigToCell = jettonMinterConfigToCell;
 exports.jettonWalletConfigToCell = jettonWalletConfigToCell;
 exports.makeSnakeCell = makeSnakeCell;
 exports.mergeConstructorDicts = mergeConstructorDicts;
 exports.multisigConfigToCell = multisigConfigToCell;
+exports.nullObject = nullObject;
+exports.numberTypeLikeToAbsBigInt = numberTypeLikeToAbsBigInt;
 exports.openAndDeployAllStoragesTemplate = openAndDeployAllStoragesTemplate;
 exports.orderConfigToCell = orderConfigToCell;
 exports.parseDirectory = parseDirectory;
+exports.parseTonAddress = parseTonAddress;
+exports.printDeepDecode = printDeepDecode;
+exports.printDeepDiff = printDeepDiff;
 exports.printTransactionTrace = printTransactionTrace;
+exports.publicKeyToHash = publicKeyToHash;
 exports.saveAllTypes = saveAllTypes;
 exports.saveBaseEventHandler = saveBaseEventHandler;
 exports.saveConstantsFile = saveConstantsFile;
@@ -6274,10 +7128,14 @@ exports.saveTonObjectUnwrapper = saveTonObjectUnwrapper;
 exports.saveViewFunctions = saveViewFunctions;
 exports.sendInternalMessageAndExpect = sendInternalMessageAndExpect;
 exports.sendMessageViaMultisigAndExpect = sendMessageViaMultisigAndExpect;
+exports.serializeAddressList = serializeAddressList;
+exports.serializePayees = serializePayees;
 exports.setLzTonSdkSaveToJson = setLzTonSdkSaveToJson;
 exports.setLzTonSdkWriteToConsole = setLzTonSdkWriteToConsole;
 exports.storageCollected = storageCollected;
 exports.to32ByteBuffer = to32ByteBuffer;
 exports.toHaveTransactions = toHaveTransactions;
+exports.toPathArray = toPathArray;
+exports.trim0x = trim0x;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map