@layerzerolabs/ton-sdk-tools 3.0.80 → 3.0.81

package/dist/index.cjs

@@ -345,8 +345,8 @@ function parseClasses(strInput) {
   }
   return results;
 }
-function saveBaseEventHandler(directory, opcodesImportPath = "../constants", allTypesImportPath = "./allTypes", tonObjectUnwrapperImportPath = "./TonObjectUnwrapper", tonContractWrapperImportPath = "./TonContractWrapper") {
-  const allTypes = ["ExtendedContract", "ActionEvent", "Md", "nameMap"].sort();
+function saveBaseEventHandler(directory, opcodesImportPath = "../constants", allTypesImportPath = "./allTypes", tonObjectUnwrapperImportPath = "./TonObjectUnwrapper", tonContractWrapperImportPath = "./TonContractWrapper", baseWrapperImportPath = "@layerzerolabs/ton-sdk-tools") {
+  const allTypes = ["ActionEvent", "Md", "nameMap"].sort();
   const savedCode = `${file_signature_header}
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
@@ -354,6 +354,7 @@ 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 { OPCODES } from '${opcodesImportPath}'
 
@@ -385,14 +386,14 @@ export class LzEvent {
     async load(wrapper: ExtendedContract<TonContractWrapper>): Promise<boolean> {
         this._event = await this._eventPromise
         this.topic = TonContractWrapper.bigintToAsciiString(this._event.topic)
-        this.bodyName = await TonObjectUnwrapper.getTypeOf(wrapper, this._event.body)
+        this.bodyName = await wrapper.getTypeOf(this._event.body)
         const tsCasterName = 'get' + nameMap[this.bodyName] + 'ToTS'
 
         const method = TonObjectUnwrapper[tsCasterName as keyof typeof TonObjectUnwrapper]
         if (typeof method === 'function') {
             this.body = await method(wrapper, this._event.body)
         } else {
-            console.log('Method' + tsCasterName + 'does not exist.')
+            console.log('Method' + tsCasterName + ' does not exist.')
         }
 
         this.initialStorage = this._event.initialStorage
@@ -494,172 +495,7 @@ export class LzEventHandler extends BaseEventHandler {
 `;
   fs__namespace.writeFileSync(path__namespace.join(directory, "LzEventHandler.ts"), savedCode);
 }
-function saveClasslibWrapper(directory, baseWrapper) {
-  if (baseWrapper === void 0) {
-    baseWrapper = `import { BaseWrapper, SendRequestOptions } from '@layerzerolabs/ton-sdk-tools'`;
-  }
-  const savedCode = `${file_signature_header}
-
-import {
-    Address,
-    Cell,
-    ContractProvider,
-    ContractState,
-    Sender,
-    SenderArguments,
-    TupleItem,
-    TupleReader,
-    contractAddress,
-    beginCell,
-} from '@ton/core'
-
-${baseWrapper}
-
-export type GetIntFnNames =
-    | 'cl::get<uint8>'
-    | 'cl::get<uint16>'
-    | 'cl::get<uint32>'
-    | 'cl::get<uint64>'
-    | 'cl::get<uint256>'
-    | 'cl::get<coins>'
-    | 'cl::get<bool>'
-    | 'cl::get<address>'
-
-export class ClasslibWrapper extends BaseWrapper {
-    static create(code: Cell, data: Cell, workchain = 0): ClasslibWrapper {
-        const init = { code, data }
-        return new ClasslibWrapper(contractAddress(workchain, init), init)
-    }
-
-    buildRequest(
-        opCode: bigint,
-        data: Cell,
-        opts: SendRequestOptions,
-        balanceRefill = 0n,
-        queryId?: number | bigint
-    ): SenderArguments {
-        const body = this.beginMessage(opCode, queryId).storeCoins(balanceRefill).storeRef(data).endCell()
-        return this.buildSenderArguments(body, opts)
-    } 
-
-     async sendTonPayment(
-        provider: ContractProvider,
-        via: Sender,
-        opts: SendRequestOptions,
-    ): Promise<void> {
-        if (via.address === undefined) {
-            throw new Error('Sender address is not defined')
-        }
-        const request = this.buildSenderArguments(beginCell().endCell(), opts)
-        return this.sendRequest(provider, via, request)
-    }
-
-    async sendInternalMessage(
-        provider: ContractProvider,
-        via: Sender,
-        opCode: bigint,
-        md: Cell,
-        opts: SendRequestOptions,
-        balanceRefill = 0n,
-        queryId?: number | bigint
-    ): Promise<void> {
-        if (via.address === undefined) {
-            throw new Error('Sender address is not defined')
-        }
-        const request = this.buildRequest(opCode, md, opts, balanceRefill, queryId)
-        return this.sendRequest(provider, via, request)
-    }
-
-    async getFieldStack(
-        provider: ContractProvider,
-        method: string,
-        cell: Cell,
-        fieldName: bigint
-    ): Promise<TupleReader> {
-        const args: TupleItem[] = [
-            { type: 'cell', cell: cell },
-            { type: 'int', value: fieldName },
-        ]
-        const ret = await provider.get(method, args)
-        return ret.stack
-    }
-
-    async getState(provider: ContractProvider): Promise<ContractState> {
-        return provider.getState()
-    }
-
-    async getContractBalanceView(provider: ContractProvider, futureSeconds: bigint): Promise<bigint> {
-        const getResult = await provider.get('getContractBalanceView', [{ type: 'int', value: futureSeconds }])
-        return getResult.stack.readBigNumber()
-    }
-
-    async getCurrentStorageCell(provider: ContractProvider): Promise<Cell> {
-        const getResult = await provider.get('getContractStorage', [])
-        return getResult.stack.readCell()
-    }
-
-    async getViewFunction(provider: ContractProvider, method: string, args: TupleItem[]): Promise<TupleReader> {
-        const ret = await provider.get(method, args)
-        return ret.stack
-    }
-
-    async getClInt(provider: ContractProvider, method: GetIntFnNames, cell: Cell, fieldName: bigint): Promise<bigint> {
-        return (await this.getFieldStack(provider, method, cell, fieldName)).readBigNumber()
-    }
-
-    async getClAddress(provider: ContractProvider, cell: Cell, fieldName: bigint): Promise<Address> {
-        return (await this.getFieldStack(provider, 'cl::get<address>', cell, fieldName)).readAddress()
-    }
-
-    async getClCell(provider: ContractProvider, cell: Cell, fieldName: bigint): Promise<Cell> {
-        return (await this.getFieldStack(provider, 'cl::get<cellRef>', cell, fieldName)).readCell()
-    }
-
-    async getClObj(provider: ContractProvider, cell: Cell, fieldName: bigint): Promise<Cell> {
-        return (await this.getFieldStack(provider, 'cl::get<objRef>', cell, fieldName)).readCell()
-    }
-
-    async getClDict(provider: ContractProvider, cell: Cell, fieldName: bigint): Promise<Cell> {
-        return (await this.getFieldStack(provider, 'cl::get<dict256>', cell, fieldName)).readCell()
-    }
-
-    async getObject(provider: ContractProvider, method: string, args: TupleItem[]): Promise<Cell> {
-        const ret = await provider.get(method, args)
-        return ret.stack.readCell()
-    }
-
-    async getDictCellItem(provider: ContractProvider, dict_cell: Cell, key: bigint): Promise<Cell> {
-        const args: TupleItem[] = [
-            { type: 'cell', cell: dict_cell },
-            { type: 'int', value: key },
-        ]
-        const ret = await provider.get('cl::dict256::get<cellRef>', args)
-        return ret.stack.readCell()
-    }
-
-    async getDictUint256Item(provider: ContractProvider, dict_cell: Cell, key: bigint): Promise<bigint> {
-        const args: TupleItem[] = [
-            { type: 'cell', cell: dict_cell },
-            { type: 'int', value: key },
-        ]
-        const ret = await provider.get('cl::dict256::get<uint256>', args)
-        return ret.stack.readBigNumber()
-    }
-
-    async getSetDictItem(provider: ContractProvider, dict_cell: Cell, key: bigint, value: Cell): Promise<Cell> {
-        const args: TupleItem[] = [
-            { type: 'cell', cell: dict_cell },
-            { type: 'int', value: key },
-            { type: 'cell', cell: value },
-        ]
-        const ret = await provider.get('cl::dict256::setRef', args)
-        return ret.stack.readCell()
-    }
-}
-`;
-  fs__namespace.writeFileSync(path__namespace.join(directory, "ClasslibWrapper.ts"), savedCode);
-}
-function saveTonContractWrapper(tonObjects, directory, classlibWrapperImportPath = "./ClasslibWrapper") {
+function saveTonContractWrapper(tonObjects, directory, classlibWrapperImportPath = "@layerzerolabs/ton-sdk-tools") {
   const generatedMethods = Object.entries(tonObjects).map(([_, tonObject]) => tonObject.constructorCode ?? "").join("\n");
   const savedCode = `${file_signature_header}
 
@@ -684,22 +520,12 @@ export class TonContractWrapper extends ClasslibWrapper {
         return new TonContractWrapper(contractAddress(workchain, init), init)
     }
 
-    static bigintToAsciiString(num: bigint): string {
-        let result = ''
-        while (num > 0n) {
-            const charCode = Number(num & 255n)
-            result = String.fromCharCode(charCode) + result
-            num = num >> 8n
-        }
-        return result
-    }
-
     ${generatedMethods}
 }
 `;
   fs__namespace.writeFileSync(path__namespace.join(directory, "TonContractWrapper.ts"), savedCode);
 }
-function saveAllTypes(tonObjects, directory, tonContractWrapperImportPath = "./TonContractWrapper") {
+function saveAllTypes(tonObjects, directory, tonContractWrapperImportPath = "./TonContractWrapper", baseWrapperImportPath = "@layerzerolabs/ton-sdk-tools") {
   const generatedTypes = Object.entries(tonObjects).filter(([_, tonObject]) => tonObject.attributes.length > 0).map(([_, tonObject]) => "export " + (tonObject.tsTypeCode ?? "")).join("");
   const mapping = {};
   const keyMapping = {};
@@ -729,8 +555,7 @@ import { Cell, OpenedContract, beginCell } from '@ton/core'
 import { SandboxContract } from '@ton/sandbox'
 
 import { TonContractWrapper } from '${tonContractWrapperImportPath}'
-
-export type ExtendedContract<T> = SandboxContract<T> | OpenedContract<T>
+import { ExtendedContract } from '${baseWrapperImportPath}'
 
 export class LzDict {
     _cell: Cell
@@ -903,10 +728,9 @@ export class LzGasTracker {
 }`;
   fs__namespace.writeFileSync(path__namespace.join(directory, "LzGasTracker.ts"), savedCode);
 }
-function saveTonObjectUnwrapper(tonObjects, directory, allTypesImportPath = "./allTypes", tonContractWrapperImportPath = "./TonContractWrapper") {
+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),
-    "ExtendedContract",
     "LzDict",
     "Md",
     "nameMap"
@@ -922,12 +746,10 @@ import { flattenTransaction } from '@ton/test-utils'
 import { getLzDict,
 ${allTypes.map((type) => "    " + type + ",\n").join("")}} from '${allTypesImportPath}'
 import { TonContractWrapper } from '${tonContractWrapperImportPath}'
+import { ClasslibWrapper } from '${classlibWrapperImportPath}'
+import { ExtendedContract } from '${baseWrapperImportPath}'
 
 export class TonObjectUnwrapper {
-    static async getTypeOf(provider: ExtendedContract<TonContractWrapper>, obj_cell: Cell): Promise<string> {
-        const ret = await provider.getViewFunction('cl::typeof', [{ type: 'cell', cell: obj_cell }])
-        return TonContractWrapper.bigintToAsciiString(ret.readBigNumber())
-    }
 ${Array.from(
     new Map(
       Object.entries(tonObjects).filter(([_, constructor]) => constructor.deconstructorCode).map(([_, constructor]) => [constructor.tonName, constructor.deconstructorCode])
@@ -1372,6 +1194,110 @@ var BaseWrapper = class {
     return core.beginCell().storeUint(opcode, 32).storeUint(queryId ?? randomQueryId, 64);
   }
 };
+var ClasslibWrapper = class _ClasslibWrapper extends BaseWrapper {
+  static create(code, data, workchain = 0) {
+    const init = { code, data };
+    return new _ClasslibWrapper(core.contractAddress(workchain, init), init);
+  }
+  buildRequest(opCode, data, opts, balanceRefill = 0n, queryId) {
+    const body = this.beginMessage(opCode, queryId).storeCoins(balanceRefill).storeRef(data).endCell();
+    return this.buildSenderArguments(body, opts);
+  }
+  async sendTonPayment(provider, via, opts) {
+    if (via.address === void 0) {
+      throw new Error("Sender address is not defined");
+    }
+    const request = this.buildSenderArguments(core.beginCell().endCell(), opts);
+    return this.sendRequest(provider, via, request);
+  }
+  async sendInternalMessage(provider, via, opCode, md, opts, balanceRefill = 0n, queryId) {
+    if (via.address === void 0) {
+      throw new Error("Sender address is not defined");
+    }
+    const request = this.buildRequest(opCode, md, opts, balanceRefill, queryId);
+    return this.sendRequest(provider, via, request);
+  }
+  async getFieldStack(provider, method, cell, fieldName) {
+    const args = [
+      { type: "cell", cell },
+      { type: "int", value: fieldName }
+    ];
+    const ret = await provider.get(method, args);
+    return ret.stack;
+  }
+  async getState(provider) {
+    return provider.getState();
+  }
+  async getContractBalanceView(provider, futureSeconds) {
+    const getResult = await provider.get("getContractBalanceView", [{ type: "int", value: futureSeconds }]);
+    return getResult.stack.readBigNumber();
+  }
+  async getCurrentStorageCell(provider) {
+    const getResult = await provider.get("getContractStorage", []);
+    return getResult.stack.readCell();
+  }
+  async getViewFunction(provider, method, args) {
+    const ret = await provider.get(method, args);
+    return ret.stack;
+  }
+  async getClInt(provider, method, cell, fieldName) {
+    return (await this.getFieldStack(provider, method, cell, fieldName)).readBigNumber();
+  }
+  async getClAddress(provider, cell, fieldName) {
+    return (await this.getFieldStack(provider, "cl::get<address>", cell, fieldName)).readAddress();
+  }
+  async getClCell(provider, cell, fieldName) {
+    return (await this.getFieldStack(provider, "cl::get<cellRef>", cell, fieldName)).readCell();
+  }
+  async getClObj(provider, cell, fieldName) {
+    return (await this.getFieldStack(provider, "cl::get<objRef>", cell, fieldName)).readCell();
+  }
+  async getClDict(provider, cell, fieldName) {
+    return (await this.getFieldStack(provider, "cl::get<dict256>", cell, fieldName)).readCell();
+  }
+  async getObject(provider, method, args) {
+    const ret = await provider.get(method, args);
+    return ret.stack.readCell();
+  }
+  async getTypeOf(provider, cell) {
+    const ret = await provider.get("cl::typeof", [{ type: "cell", cell }]);
+    return _ClasslibWrapper.bigintToAsciiString(ret.stack.readBigNumber());
+  }
+  async getDictCellItem(provider, dict_cell, key) {
+    const args = [
+      { type: "cell", cell: dict_cell },
+      { type: "int", value: key }
+    ];
+    const ret = await provider.get("cl::dict256::get<cellRef>", args);
+    return ret.stack.readCell();
+  }
+  async getDictUint256Item(provider, dict_cell, key) {
+    const args = [
+      { type: "cell", cell: dict_cell },
+      { type: "int", value: key }
+    ];
+    const ret = await provider.get("cl::dict256::get<uint256>", args);
+    return ret.stack.readBigNumber();
+  }
+  async getSetDictItem(provider, dict_cell, key, value) {
+    const args = [
+      { type: "cell", cell: dict_cell },
+      { type: "int", value: key },
+      { type: "cell", cell: value }
+    ];
+    const ret = await provider.get("cl::dict256::setRef", args);
+    return ret.stack.readCell();
+  }
+  static bigintToAsciiString(num) {
+    let result = "";
+    while (num > 0n) {
+      const charCode = Number(num & 255n);
+      result = String.fromCharCode(charCode) + result;
+      num = num >> 8n;
+    }
+    return result;
+  }
+};
 function getSharedOptions(input) {
   const ret = {
     relativeSrcPath: "../../src",
@@ -1430,10 +1356,13 @@ import {
     cellFromArtifact,
     getRandomInt,
     printTransactionTrace,
+    ExtendedContract,
+    sendMessageViaMultisigAndExpect,
+    sendInternalMessageAndExpect,
+    toHaveTransactions
 } from '@layerzerolabs/ton-sdk-tools'
 
 import {
-    ExtendedContract,
     LzDict,
     LzEventHandler,
     MdPacketSent,
@@ -1597,30 +1526,6 @@ export interface LzReceiveExpectArgs {
     gasValue?: bigint
 }
 
-export interface SendInternalMessageAndExpectArgs {
-    sender: Treasury
-    contract: SandboxContract<TonContractWrapper>
-    expectedTransactions: FlatTransactionComparable[]
-    opCode: bigint
-    md: Cell
-    value: bigint
-    balanceRefill?: bigint
-    queryId?: bigint
-    profile?: Profile
-    recursiveDecode?: boolean
-}
-
-export interface SendMessageViaMultisigAndExpectArgs {
-    blockchain: Blockchain
-    multiSigContract: SandboxContract<Multisig>
-    messageBody: Cell
-    signers: SandboxContract<TreasuryContract>[]
-    targetContract: SandboxContract<TonContractWrapper | JettonMinter>
-    deploy: boolean
-    expectedTransactions: FlatTransactionComparable[]
-    recursiveDecode?: boolean
-}
-
 export interface OutOfOrder {
     actions: Action[]
 }
@@ -1846,170 +1751,6 @@ export function readJsonFile(filePath: string): unknown {
     }
 }
 
-export async function openAndDeployAllStorages(
-    blockchain: Blockchain,
-    multiSigOwner1: SandboxContract<TreasuryContract>
-): Promise<SandboxContract<TonContractWrapper>> {
-    // ===================================open allStorages=====================================
-
-    const allStorages = blockchain.openContract(
-        TonContractWrapper.create(cellFromArtifact(AllStoragesArtifact), beginCell().endCell())
-    )
-
-    // ===================================deploy allStorages=====================================
-
-    await sendInternalMessageAndExpect({
-        value: protocolSetupGas['AllStorages.INITIALIZE'],
-        sender: multiSigOwner1.getSender(),
-        contract: allStorages,
-        expectedTransactions: [
-            {
-                from: multiSigOwner1.address,
-                to: allStorages.address,
-                deploy: true,
-                success: true,
-            },
-        ],
-        opCode: OPCODES.BaseInterface_OP_INITIALIZE,
-        md: emptyObject,
-        balanceRefill: toNano('1'),
-    })
-
-    return allStorages
-}
-
-export async function sendMessageViaMultisigAndExpect({
-    blockchain,
-    multiSigContract,
-    messageBody,
-    signers,
-    targetContract,
-    deploy,
-    expectedTransactions = [],
-    recursiveDecode = RECURSIVE_DECODE,
-}: SendMessageViaMultisigAndExpectArgs): Promise<SendMessageResult> {
-    const curTime = (): number => blockchain.now ?? Math.floor(Date.now() / 1000)
-
-    const initialSeqno = (await multiSigContract.getMultisigData()).nextOrderSeqno
-    const orderAddress = await multiSigContract.getOrderAddress(initialSeqno)
-
-    const rawMessageBuilder = beginCell().storeUint(0x18, 6).storeAddress(targetContract.address).storeCoins(0)
-
-    let rawMessageCell: Cell
-
-    if (targetContract.init === undefined) {
-        throw new Error('targetContract.init is undefined')
-    }
-
-    if (deploy) {
-        const targetContractStateInit = beginCell()
-            .storeUint(6, 5)
-            .storeRef(targetContract.init.code)
-            .storeRef(targetContract.init.data)
-            .endCell()
-
-        rawMessageCell = rawMessageBuilder
-            .storeUint(7, 108)
-            .storeRef(targetContractStateInit)
-            .storeRef(messageBody)
-            .endCell()
-    } else {
-        rawMessageCell = rawMessageBuilder.storeUint(1, 107).storeRef(messageBody).endCell()
-    }
-
-    const orderMsg: TransferRequest = {
-        type: 'transfer',
-        sendMode: SendMode.CARRY_ALL_REMAINING_BALANCE,
-        message: rawMessageCell,
-    }
-
-    // one of the signers proposes deploying the controller
-    let internalMsgResults = await multiSigContract.sendNewOrder(signers[0].getSender(), [orderMsg], curTime() + 100)
-
-    expect(internalMsgResults.transactions).toHaveTransaction({
-        from: multiSigContract.address,
-        to: orderAddress,
-        deploy: true,
-        success: true,
-    })
-
-    // that makes sure that the target contract is a sandbox<TonContractWrapper>
-    if (recursiveDecode && 'getCurrentStorageCell' in targetContract) {
-        await txDecoder(targetContract, internalMsgResults)
-    }
-
-    const orderContract = blockchain.openContract(Order.createFromAddress(orderAddress))
-    const orderDataBefore = await orderContract.getOrderData()
-
-    // proposal by a signer is considered automatically approved
-    expect(orderDataBefore.approvals_num).toBe(1)
-    expect(orderDataBefore.executed).toBe(false)
-
-    // approve it by the other 2 signers
-    await orderContract.sendApprove(signers[1].getSender(), 1)
-    internalMsgResults = await orderContract.sendApprove(signers[2].getSender(), 2)
-
-    // the order should send tell the multisig to execute the order
-    expect(internalMsgResults.transactions).toHaveTransaction({
-        from: orderAddress,
-        to: multiSigContract.address,
-        op: MultiSigOpCodes.multisig.execute,
-        success: true,
-    })
-
-    // the multisig should deliver the message to the target contract
-    expect(internalMsgResults.transactions).toHaveTransaction({
-        from: multiSigContract.address,
-        to: targetContract.address,
-        // deploy,
-        success: true,
-    })
-
-    toHaveTransactions(internalMsgResults.transactions, expectedTransactions)
-
-    if (recursiveDecode && 'getCurrentStorageCell' in targetContract) {
-        await txDecoder(targetContract, internalMsgResults)
-    }
-
-    return internalMsgResults
-}
-
-export async function sendInternalMessageAndExpect({
-    sender,
-    contract,
-    opCode,
-    md,
-    expectedTransactions,
-    value,
-    balanceRefill = BigInt(0),
-    queryId = BigInt(1),
-    profile,
-    recursiveDecode = RECURSIVE_DECODE,
-}: SendInternalMessageAndExpectArgs): Promise<SendMessageResult> {
-    const internalMsgResults = await contract.sendInternalMessage(sender, opCode, md, { value }, balanceRefill, queryId)
-
-    if (profile?.profileGas ?? false) {
-        const { stack } = new Error()
-        printTransactionTrace(internalMsgResults.transactions, invertedOpcodes, stack, profile)
-    }
-
-    if (recursiveDecode) {
-        await txDecoder(contract, internalMsgResults)
-    }
-
-    toHaveTransactions(internalMsgResults.transactions, expectedTransactions)
-    return internalMsgResults
-}
-
-export function toHaveTransactions(
-    actualTransactions: BlockchainTransaction[],
-    expectedTransactions: FlatTransactionComparable[]
-): void {
-    expectedTransactions.forEach((tx) => {
-        expect(actualTransactions).toHaveTransaction(tx)
-    })
-}
-
 export async function lzReceiveAndExpect({
     lzReceivePrepareMd,
     oAppFixture,
@@ -2929,7 +2670,7 @@ export async function txDecoder(
 export async function runtimeDecoder(contract: SandboxContract<TonContractWrapper>, obj: Cell): Promise<void> {
     const { tonObjects } = require('${options.relativeSrcPath}/offchain-helpers/allObjects') as { [key: string]: { [key: string]: any } }
 
-    const typeName = await TonObjectUnwrapper.getTypeOf(contract, obj)
+    const typeName = await contract.getTypeOf(obj)
 
     const tonObjectDefKey = keyMap[typeName] ?? ('' as any)
     // if key not found, return early
@@ -2963,7 +2704,7 @@ export async function runtimeDecoder(contract: SandboxContract<TonContractWrappe
 
             // If field is an objRef, try to decode the corresponding decoded value
             if (jsonField.fieldType === 'cl::t::objRef' && field instanceof Cell) {
-                let newCellFieldType = await TonObjectUnwrapper.getTypeOf(contract, field)
+                let newCellFieldType = await contract.getTypeOf(field)
                 if (newCellFieldType === 'NULL') {
                     newCellFieldType = 'cl::t::cellRef'
                 } else {
@@ -2998,7 +2739,7 @@ import ChannelArtifact from '@layerzerolabs/layerzero-v2-ton/build/Channel.compi
 import EndpointArtifact from '@layerzerolabs/layerzero-v2-ton/build/Endpoint.compiled.json'
 import SmlConnectionArtifact from '@layerzerolabs/layerzero-v2-ton/build/SmlConnection.compiled.json'
 import SmlManagerArtifact from '@layerzerolabs/layerzero-v2-ton/build/SmlManager.compiled.json'
-import { Profile, addressToBigInt, cellFromArtifact } from '@layerzerolabs/ton-sdk-tools'
+import { Profile, addressToBigInt, cellFromArtifact, sendInternalMessageAndExpect, } from '@layerzerolabs/ton-sdk-tools'
 
 import {
     OAppFixture,
@@ -3006,7 +2747,6 @@ import {
     addMsgLibToController,
     emptyObject,
     protocolSetupGas,
-    sendInternalMessageAndExpect,
     setDefaultEndpointConfig,
     wireChannels,
 } from './auto-utils-common'
@@ -3370,7 +3110,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 { Profile, addressToBigInt, cellFromArtifact } from '@layerzerolabs/ton-sdk-tools'
+import { ExtendedContract, Profile, addressToBigInt, cellFromArtifact, sendInternalMessageAndExpect, sendMessageViaMultisigAndExpect, } from '@layerzerolabs/ton-sdk-tools'
 
 import {
     OAppFixture,
@@ -3385,14 +3125,12 @@ import {
     protocolSetupGas,
     publicKeyToHash,
     requireDefined,
-    sendInternalMessageAndExpect,
-    sendMessageViaMultisigAndExpect,
     serializeAddressList,
     setDefaultEndpointConfig,
     wireChannels,
 } from './auto-utils-common'
+
 import {
-    ExtendedContract,
     LzDict,
     LzEventHandler,
     MdPacketSent,
@@ -6346,9 +6084,126 @@ function printTransactionTrace(transactions, opcodeInfo, callerStack, profile) {
   );
   if (profile?.profileGas) sortAndSave(filePath, gasInfo);
 }
+async function sendMessageViaMultisigAndExpect({
+  blockchain,
+  multiSigContract,
+  messageBody,
+  signers,
+  targetContract,
+  deploy,
+  expectedTransactions = [],
+  recursiveDecode = false,
+  txDecoder
+}) {
+  const curTime = () => blockchain.now ?? Math.floor(Date.now() / 1e3);
+  const initialSeqno = (await multiSigContract.getMultisigData()).nextOrderSeqno;
+  const orderAddress = await multiSigContract.getOrderAddress(initialSeqno);
+  const rawMessageBuilder = core.beginCell().storeUint(24, 6).storeAddress(targetContract.address).storeCoins(0);
+  let rawMessageCell;
+  if (targetContract.init === void 0) {
+    throw new Error("targetContract.init is undefined");
+  }
+  if (deploy) {
+    const targetContractStateInit = core.beginCell().storeUint(6, 5).storeRef(targetContract.init.code ?? core.beginCell().endCell()).storeRef(targetContract.init.data ?? core.beginCell().endCell()).endCell();
+    rawMessageCell = rawMessageBuilder.storeUint(7, 108).storeRef(targetContractStateInit).storeRef(messageBody).endCell();
+  } else {
+    rawMessageCell = rawMessageBuilder.storeUint(1, 107).storeRef(messageBody).endCell();
+  }
+  const orderMsg = {
+    type: "transfer",
+    sendMode: core.SendMode.CARRY_ALL_REMAINING_BALANCE,
+    message: rawMessageCell
+  };
+  let internalMsgResults = await multiSigContract.sendNewOrder(signers[0].getSender(), [orderMsg], curTime() + 100);
+  expect(internalMsgResults.transactions).toHaveTransaction({
+    from: multiSigContract.address,
+    to: orderAddress,
+    deploy: true,
+    success: true
+  });
+  if (recursiveDecode && "getCurrentStorageCell" in targetContract && txDecoder) {
+    await txDecoder(targetContract, internalMsgResults);
+  }
+  const orderContract = blockchain.openContract(Order.createFromAddress(orderAddress));
+  const orderDataBefore = await orderContract.getOrderData();
+  expect(orderDataBefore.approvals_num).toBe(1);
+  expect(orderDataBefore.executed).toBe(false);
+  await orderContract.sendApprove(signers[1].getSender(), 1);
+  internalMsgResults = await orderContract.sendApprove(signers[2].getSender(), 2);
+  expect(internalMsgResults.transactions).toHaveTransaction({
+    from: orderAddress,
+    to: multiSigContract.address,
+    op: MultiSigOpCodes.multisig.execute,
+    success: true
+  });
+  expect(internalMsgResults.transactions).toHaveTransaction({
+    from: multiSigContract.address,
+    to: targetContract.address,
+    // deploy,
+    success: true
+  });
+  toHaveTransactions(internalMsgResults.transactions, expectedTransactions);
+  if (recursiveDecode && "getCurrentStorageCell" in targetContract && txDecoder) {
+    await txDecoder(targetContract, internalMsgResults);
+  }
+  return internalMsgResults;
+}
+async function sendInternalMessageAndExpect({
+  sender,
+  contract,
+  opCode,
+  md,
+  expectedTransactions,
+  value,
+  balanceRefill = BigInt(0),
+  queryId = BigInt(1),
+  profile,
+  recursiveDecode = false,
+  txDecoder,
+  invertedOpcodes
+}) {
+  const internalMsgResults = await contract.sendInternalMessage(sender, opCode, md, { value }, balanceRefill, queryId);
+  if (profile?.profileGas ?? false) {
+    const { stack } = new Error();
+    printTransactionTrace(internalMsgResults.transactions, invertedOpcodes ?? {}, stack, profile);
+  }
+  if (recursiveDecode && txDecoder) {
+    await txDecoder(contract, internalMsgResults);
+  }
+  toHaveTransactions(internalMsgResults.transactions, expectedTransactions);
+  return internalMsgResults;
+}
+function toHaveTransactions(actualTransactions, expectedTransactions) {
+  expectedTransactions.forEach((tx) => {
+    expect(actualTransactions).toHaveTransaction(tx);
+  });
+}
+async function openAndDeployAllStoragesTemplate(blockchain, deployer, artifact, gasValue, opCode, md) {
+  const allStorages = blockchain.openContract(
+    ClasslibWrapper.create(cellFromArtifact(artifact), core.beginCell().endCell())
+  );
+  await sendInternalMessageAndExpect({
+    value: gasValue,
+    sender: deployer.getSender(),
+    contract: allStorages,
+    expectedTransactions: [
+      {
+        from: deployer.address,
+        to: allStorages.address,
+        deploy: true,
+        success: true
+      }
+    ],
+    opCode,
+    md,
+    balanceRefill: core.toNano("1")
+  });
+  return allStorages;
+}
 
 exports.BASE_CHAIN_ID = BASE_CHAIN_ID;
 exports.BaseWrapper = BaseWrapper;
+exports.ClasslibWrapper = ClasslibWrapper;
 exports.Errors = Errors;
 exports.JettonMinter = JettonMinter;
 exports.JettonWallet = JettonWallet;
@@ -6396,12 +6251,12 @@ exports.jettonWalletConfigToCell = jettonWalletConfigToCell;
 exports.makeSnakeCell = makeSnakeCell;
 exports.mergeConstructorDicts = mergeConstructorDicts;
 exports.multisigConfigToCell = multisigConfigToCell;
+exports.openAndDeployAllStoragesTemplate = openAndDeployAllStoragesTemplate;
 exports.orderConfigToCell = orderConfigToCell;
 exports.parseDirectory = parseDirectory;
 exports.printTransactionTrace = printTransactionTrace;
 exports.saveAllTypes = saveAllTypes;
 exports.saveBaseEventHandler = saveBaseEventHandler;
-exports.saveClasslibWrapper = saveClasslibWrapper;
 exports.saveConstantsFile = saveConstantsFile;
 exports.saveEventsFile = saveEventsFile;
 exports.saveLzEventHandler = saveLzEventHandler;
@@ -6410,7 +6265,10 @@ exports.saveObjectsAsTS = saveObjectsAsTS;
 exports.saveTonContractWrapper = saveTonContractWrapper;
 exports.saveTonObjectUnwrapper = saveTonObjectUnwrapper;
 exports.saveViewFunctions = saveViewFunctions;
+exports.sendInternalMessageAndExpect = sendInternalMessageAndExpect;
+exports.sendMessageViaMultisigAndExpect = sendMessageViaMultisigAndExpect;
 exports.storageCollected = storageCollected;
 exports.to32ByteBuffer = to32ByteBuffer;
+exports.toHaveTransactions = toHaveTransactions;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map