@tonappchain/sdk 0.6.1-v3.0.1 → 0.6.1-v3.0.3

package/dist/sdk/Utils.d.ts

@@ -0,0 +1,18 @@
+import { Address, Cell } from '@ton/ton';
+import { AbiCoder } from 'ethers';
+import { EvmProxyMsg, TransactionLinker, ValidExecutors } from '../structs/Struct';
+import { RandomNumberByTimestamp } from '../structs/InternalStruct';
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function generateRandomNumber(interval: number): number;
+export declare function generateRandomNumberByTimestamp(): RandomNumberByTimestamp;
+export declare function calculateContractAddress(code: Cell, data: Cell): Promise<Address>;
+export declare function buildEvmDataCell(transactionLinker: TransactionLinker, evmProxyMsg: EvmProxyMsg, validExecutors: ValidExecutors): Cell;
+export declare function formatSolidityMethodName(methodName?: string): string;
+export declare function generateTransactionLinker(caller: string, shardCount: number): TransactionLinker;
+export declare function validateTVMAddress(address: string): void;
+export declare function validateEVMAddress(address: string): void;
+export declare function calculateEVMTokenAddress(abiCoder: AbiCoder, tokenUtilsAddress: string, crossChainLayerTokenBytecode: string, crossChainLayerAddress: string, tvmAddress: string): string;
+export declare const convertKeysToCamelCase: <T>(data: T) => T;
+export declare const calculateRawAmount: (amount: number, decimals: number) => bigint;
+export declare const calculateAmount: (rawAmount: bigint, decimals: number) => number;
+export declare const toCamelCaseTransformer: (data: any) => any;

package/dist/sdk/Utils.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCaseTransformer = exports.calculateAmount = exports.calculateRawAmount = exports.convertKeysToCamelCase = exports.sleep = void 0;
+exports.generateRandomNumber = generateRandomNumber;
+exports.generateRandomNumberByTimestamp = generateRandomNumberByTimestamp;
+exports.calculateContractAddress = calculateContractAddress;
+exports.buildEvmDataCell = buildEvmDataCell;
+exports.formatSolidityMethodName = formatSolidityMethodName;
+exports.generateTransactionLinker = generateTransactionLinker;
+exports.validateTVMAddress = validateTVMAddress;
+exports.validateEVMAddress = validateEVMAddress;
+exports.calculateEVMTokenAddress = calculateEVMTokenAddress;
+const ton_1 = require("@ton/ton");
+const ethers_1 = require("ethers");
+const errors_1 = require("../errors");
+const Consts_1 = require("./Consts");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.sleep = sleep;
+function generateRandomNumber(interval) {
+    return Math.round(Math.random() * interval);
+}
+function generateRandomNumberByTimestamp() {
+    const timestamp = Math.floor(+new Date() / 1000);
+    return {
+        timestamp,
+        randomNumber: timestamp + generateRandomNumber(1000),
+    };
+}
+async function calculateContractAddress(code, data) {
+    const stateInit = (0, ton_1.beginCell)().store((0, ton_1.storeStateInit)({ code, data })).endCell();
+    return new ton_1.Address(0, stateInit.hash());
+}
+function buildEvmDataCell(transactionLinker, evmProxyMsg, validExecutors) {
+    const evmArguments = evmProxyMsg.encodedParameters
+        ? Buffer.from(evmProxyMsg.encodedParameters.split('0x')[1], 'hex').toString('base64')
+        : null;
+    const json = JSON.stringify({
+        evmCall: {
+            target: evmProxyMsg.evmTargetAddress,
+            methodName: formatSolidityMethodName(evmProxyMsg.methodName),
+            arguments: evmArguments,
+            gasLimit: Number(evmProxyMsg.gasLimit),
+        },
+        shardsKey: transactionLinker.shardsKey,
+        shardCount: transactionLinker.shardCount,
+        evmValidExecutors: validExecutors.tac,
+        tvmValidExecutors: validExecutors.ton,
+    });
+    return (0, ton_1.beginCell)().storeStringTail(json).endCell();
+}
+function formatSolidityMethodName(methodName) {
+    if (!methodName)
+        return '';
+    if (!Consts_1.SOLIDITY_SIGNATURE_REGEX.test(methodName)) {
+        throw (0, errors_1.invalidMethodNameError)(methodName);
+    }
+    return Consts_1.SOLIDITY_METHOD_NAME_REGEX.test(methodName) ? `${methodName}(bytes,bytes)` : methodName;
+}
+function generateTransactionLinker(caller, shardCount) {
+    const random = generateRandomNumberByTimestamp();
+    return {
+        caller: ton_1.Address.normalize(caller),
+        shardCount,
+        shardsKey: String(random.randomNumber),
+        timestamp: random.timestamp,
+    };
+}
+function validateTVMAddress(address) {
+    try {
+        ton_1.Address.parse(address); // will throw on error address
+    }
+    catch {
+        throw (0, errors_1.tvmAddressError)(address);
+    }
+}
+function validateEVMAddress(address) {
+    if (!(0, ethers_1.isAddress)(address)) {
+        throw (0, errors_1.evmAddressError)(address);
+    }
+}
+function calculateEVMTokenAddress(abiCoder, tokenUtilsAddress, crossChainLayerTokenBytecode, crossChainLayerAddress, tvmAddress) {
+    const salt = ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(['string'], [tvmAddress]));
+    const initCode = ethers_1.ethers.solidityPacked(['bytes', 'bytes'], [crossChainLayerTokenBytecode, abiCoder.encode(['address'], [crossChainLayerAddress])]);
+    const initCodeHash = ethers_1.ethers.keccak256(initCode);
+    return ethers_1.ethers.getCreate2Address(tokenUtilsAddress, salt, initCodeHash);
+}
+const snakeToCamel = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+const convertKeysToCamelCase = (data) => {
+    if (Array.isArray(data)) {
+        return data.map(exports.convertKeysToCamelCase);
+    }
+    else if (data !== null && typeof data === 'object') {
+        return Object.keys(data).reduce((acc, key) => {
+            const camelKey = snakeToCamel(key);
+            acc[camelKey] = (0, exports.convertKeysToCamelCase)(data[key]);
+            return acc;
+        }, {});
+    }
+    return data;
+};
+exports.convertKeysToCamelCase = convertKeysToCamelCase;
+const calculateRawAmount = (amount, decimals) => {
+    const [integerPart, fractionalPart = ''] = amount.toString().split('.');
+    // Ensure the fractional part has enough digits
+    const paddedFraction = fractionalPart.padEnd(decimals, '0').slice(0, decimals);
+    return BigInt(integerPart + paddedFraction);
+};
+exports.calculateRawAmount = calculateRawAmount;
+const calculateAmount = (rawAmount, decimals) => {
+    const rawStr = rawAmount.toString();
+    if (rawStr.length <= decimals) {
+        return Number(`0.${rawStr.padStart(decimals, '0')}`);
+    }
+    const integerPart = rawStr.slice(0, -decimals);
+    const fractionalPart = rawStr.slice(-decimals).replace(/0+$/, '');
+    return Number(fractionalPart ? `${integerPart}.${fractionalPart}` : integerPart);
+};
+exports.calculateAmount = calculateAmount;
+const toCamelCaseTransformer = (data) => {
+    try {
+        const parsedData = JSON.parse(data);
+        return (0, exports.convertKeysToCamelCase)(parsedData);
+    }
+    catch {
+        return data;
+    }
+};
+exports.toCamelCaseTransformer = toCamelCaseTransformer;

package/dist/sender/RawSender.d.ts

@@ -0,0 +1,14 @@
+import type { ContractOpener } from '../structs/Struct';
+import type { ShardTransaction } from '../structs/InternalStruct';
+import { Network } from '../structs/Struct';
+import { SenderAbstraction, WalletInstance } from './SenderAbstraction';
+export declare class RawSender implements SenderAbstraction {
+    private wallet;
+    private secretKey;
+    constructor(wallet: WalletInstance, secretKey: Buffer);
+    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain: Network, contractOpener: ContractOpener): Promise<unknown>;
+    getSenderAddress(): string;
+    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, _chain: Network, contractOpener: ContractOpener): Promise<void | (import("@ton/sandbox").SendMessageResult & {
+        result: void;
+    })>;
+}

package/dist/sender/RawSender.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawSender = void 0;
+const ton_1 = require("@ton/ton");
+const ton_2 = require("@ton/ton");
+const SenderAbstraction_1 = require("./SenderAbstraction");
+const HighloadWalletV3_1 = require("../wrappers/HighloadWalletV3");
+class RawSender {
+    constructor(wallet, secretKey) {
+        this.wallet = wallet;
+        this.secretKey = secretKey;
+    }
+    async sendShardTransactions(shardTransactions, delay, chain, contractOpener) {
+        const walletContract = contractOpener.open(this.wallet);
+        const isBatchSendSupported = walletContract instanceof HighloadWalletV3_1.HighloadWalletV3 || walletContract instanceof ton_1.WalletContractV5R1;
+        if (isBatchSendSupported) {
+            const messages = [];
+            for (const shardTx of shardTransactions) {
+                for (const message of shardTx.messages) {
+                    messages.push((0, ton_1.internal)({
+                        to: message.address,
+                        value: (0, ton_1.fromNano)(message.value),
+                        bounce: true,
+                        body: message.payload,
+                    }));
+                }
+            }
+            const seqno = await walletContract.getSeqno();
+            await (0, SenderAbstraction_1.sleep)(delay * 1000);
+            return walletContract.sendTransfer({
+                seqno,
+                secretKey: this.secretKey,
+                messages,
+                sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
+            });
+        }
+        else {
+            const results = [];
+            for (const shardTx of shardTransactions) {
+                results.push(await this.sendShardTransaction(shardTx, delay, chain, contractOpener));
+            }
+            return results;
+        }
+    }
+    getSenderAddress() {
+        return this.wallet.address.toString();
+    }
+    async sendShardTransaction(shardTransaction, delay, _chain, contractOpener) {
+        const walletContract = contractOpener.open(this.wallet);
+        await (0, SenderAbstraction_1.sleep)(delay * 1000);
+        const seqno = await walletContract.getSeqno();
+        const messages = [];
+        for (const message of shardTransaction.messages) {
+            messages.push((0, ton_1.internal)({
+                to: message.address,
+                value: (0, ton_1.fromNano)(message.value),
+                bounce: true,
+                body: message.payload,
+            }));
+        }
+        await (0, SenderAbstraction_1.sleep)(delay * 1000);
+        return walletContract.sendTransfer({
+            seqno,
+            secretKey: this.secretKey,
+            messages,
+            sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
+        });
+    }
+}
+exports.RawSender = RawSender;

package/dist/sender/SenderAbstraction.d.ts

@@ -0,0 +1,20 @@
+import type { Contract, ContractProvider, MessageRelaxed, SendMode } from '@ton/ton';
+import type { ContractOpener } from '../structs/Struct';
+import type { ShardTransaction } from '../structs/InternalStruct';
+import { Network } from '../structs/Struct';
+export declare const sleep: (ms: number) => Promise<unknown>;
+export interface WalletInstance extends Contract {
+    getSeqno(provider: ContractProvider): Promise<number>;
+    sendTransfer(provider: ContractProvider, args: {
+        seqno: number;
+        secretKey: Buffer;
+        messages: MessageRelaxed[];
+        sendMode: SendMode;
+        timeout?: number;
+    }): Promise<void>;
+}
+export interface SenderAbstraction {
+    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<unknown>;
+    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<unknown>;
+    getSenderAddress(): string;
+}

package/dist/sender/SenderAbstraction.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.sleep = sleep;

package/dist/sender/SenderFactory.d.ts

@@ -0,0 +1,33 @@
+import { WalletContractV2R1, WalletContractV2R2, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5R1 } from '@ton/ton';
+import { TonConnectUI } from '@tonconnect/ui';
+import { SenderAbstraction } from './SenderAbstraction';
+import { Network } from '../structs/Struct';
+import { HighloadWalletV3 } from '../wrappers/HighloadWalletV3';
+export type WalletVersion = 'V2R1' | 'V2R2' | 'V3R1' | 'V3R2' | 'V4' | 'V5R1' | 'HIGHLOAD_V3';
+export declare const wallets: {
+    V2R1: typeof WalletContractV2R1;
+    V2R2: typeof WalletContractV2R2;
+    V3R1: typeof WalletContractV3R1;
+    V3R2: typeof WalletContractV3R2;
+    V4: typeof WalletContractV4;
+    V5R1: typeof WalletContractV5R1;
+    HIGHLOAD_V3: typeof HighloadWalletV3;
+};
+export declare class SenderFactory {
+    static getSender(params: {
+        network: Network;
+        version: WalletVersion;
+        mnemonic: string;
+        options?: {
+            v5r1?: {
+                subwalletNumber?: number;
+            };
+            highloadV3?: {
+                subwalletId?: number;
+                timeout?: number;
+            };
+        };
+    } | {
+        tonConnect: TonConnectUI;
+    }): Promise<SenderAbstraction>;
+}

package/dist/sender/SenderFactory.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderFactory = exports.wallets = void 0;
+const ton_1 = require("@ton/ton");
+const ton_crypto_1 = require("ton-crypto");
+const RawSender_1 = require("./RawSender");
+const TonConnectSender_1 = require("./TonConnectSender");
+const errors_1 = require("../errors");
+const Struct_1 = require("../structs/Struct");
+const HighloadWalletV3_1 = require("../wrappers/HighloadWalletV3");
+exports.wallets = {
+    V2R1: ton_1.WalletContractV2R1,
+    V2R2: ton_1.WalletContractV2R2,
+    V3R1: ton_1.WalletContractV3R1,
+    V3R2: ton_1.WalletContractV3R2,
+    V4: ton_1.WalletContractV4,
+    V5R1: ton_1.WalletContractV5R1,
+    HIGHLOAD_V3: HighloadWalletV3_1.HighloadWalletV3,
+};
+class SenderFactory {
+    static async getSender(params) {
+        if ('tonConnect' in params) {
+            return new TonConnectSender_1.TonConnectSender(params.tonConnect);
+        }
+        if (!(params.version in exports.wallets)) {
+            throw (0, errors_1.unknownWalletError)(params.version);
+        }
+        const keypair = await (0, ton_crypto_1.mnemonicToWalletKey)(params.mnemonic.split(' '));
+        const config = {
+            workchain: 0,
+            publicKey: keypair.publicKey,
+            walletId: undefined, // for w5
+            subwalletId: undefined, // for highload v3
+            timeout: undefined, // for highload v3
+        };
+        if (params.version === 'V5R1') {
+            // manual setup of wallet id required to support wallet w5 both on mainnet and testnet
+            config.walletId = {
+                networkGlobalId: params.network === Struct_1.Network.TESTNET ? -3 : -239,
+                context: {
+                    walletVersion: 'v5r1',
+                    workchain: 0,
+                    subwalletNumber: params.options?.v5r1?.subwalletNumber ?? 0,
+                },
+            };
+        }
+        if (params.version === 'HIGHLOAD_V3') {
+            config.subwalletId = params.options?.highloadV3?.subwalletId ?? HighloadWalletV3_1.DEFAULT_SUBWALLET_ID;
+            config.timeout = params.options?.highloadV3?.timeout ?? HighloadWalletV3_1.DEFAULT_TIMEOUT;
+        }
+        const wallet = exports.wallets[params.version].create(config);
+        return new RawSender_1.RawSender(wallet, keypair.secretKey);
+    }
+}
+exports.SenderFactory = SenderFactory;

package/dist/sender/TonConnectSender.d.ts

@@ -0,0 +1,12 @@
+import { TonConnectUI } from '@tonconnect/ui';
+import type { ShardTransaction } from '../structs/InternalStruct';
+import { ContractOpener, Network } from '../structs/Struct';
+import { SenderAbstraction } from './SenderAbstraction';
+import { SendTransactionResponse } from '@tonconnect/sdk';
+export declare class TonConnectSender implements SenderAbstraction {
+    readonly tonConnect: TonConnectUI;
+    constructor(tonConnect: TonConnectUI);
+    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<SendTransactionResponse[]>;
+    getSenderAddress(): string;
+    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, chain: Network): Promise<SendTransactionResponse>;
+}

package/dist/sender/TonConnectSender.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonConnectSender = void 0;
+const protocol_1 = require("@tonconnect/protocol");
+const ui_1 = require("@tonconnect/ui");
+const Struct_1 = require("../structs/Struct");
+const SenderAbstraction_1 = require("./SenderAbstraction");
+class TonConnectSender {
+    constructor(tonConnect) {
+        this.tonConnect = tonConnect;
+    }
+    async sendShardTransactions(shardTransactions, delay, chain, contractOpener) {
+        const allMessages = [];
+        let minValidUntil = 0;
+        for (const transaction of shardTransactions) {
+            for (const message of transaction.messages) {
+                allMessages.push({
+                    address: message.address,
+                    amount: message.value.toString(),
+                    payload: protocol_1.Base64.encode(message.payload.toBoc()).toString(),
+                });
+            }
+            minValidUntil = Math.min(minValidUntil, transaction.validUntil);
+        }
+        const transaction = {
+            validUntil: minValidUntil,
+            messages: allMessages,
+            network: chain == Struct_1.Network.TESTNET ? ui_1.CHAIN.TESTNET : ui_1.CHAIN.MAINNET,
+        };
+        await (0, SenderAbstraction_1.sleep)(delay * 1000);
+        const response = await this.tonConnect.sendTransaction(transaction);
+        return [response];
+    }
+    getSenderAddress() {
+        return this.tonConnect.account?.address?.toString() || '';
+    }
+    async sendShardTransaction(shardTransaction, delay, chain) {
+        const messages = [];
+        for (const message of shardTransaction.messages) {
+            messages.push({
+                address: message.address,
+                amount: message.value.toString(),
+                payload: protocol_1.Base64.encode(message.payload.toBoc()).toString(),
+            });
+        }
+        const transaction = {
+            validUntil: shardTransaction.validUntil,
+            messages,
+            network: chain == Struct_1.Network.TESTNET ? ui_1.CHAIN.TESTNET : ui_1.CHAIN.MAINNET,
+        };
+        await (0, SenderAbstraction_1.sleep)(delay * 1000);
+        return this.tonConnect.sendTransaction(transaction);
+    }
+}
+exports.TonConnectSender = TonConnectSender;

package/dist/sender/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SenderAbstraction';
+export * from './SenderFactory';

package/dist/sender/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SenderAbstraction"), exports);
+__exportStar(require("./SenderFactory"), exports);

package/dist/structs/InternalStruct.d.ts

@@ -0,0 +1,82 @@
+import { Cell } from '@ton/ton';
+import { ContractOpener, TACSimulationResult, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, RawAssetBridgingData, StatusInfosByOperationId, OperationType, AssetType } from './Struct';
+import { AbstractProvider, ethers, Interface, InterfaceAbi } from 'ethers';
+import { mainnet, testnet } from '@tonappchain/artifacts';
+export type ShardMessage = {
+    address: string;
+    value: bigint;
+    payload: Cell;
+};
+export type ShardTransaction = {
+    validUntil: number;
+    messages: ShardMessage[];
+    network: Network;
+};
+export declare enum AssetOpType {
+    JETTON_BURN = "JETTON_BURN",
+    JETTON_TRANSFER = "JETTON_TRANSFER",
+    NFT_BURN = "NFT_BURN",
+    NFT_TRANSFER = "NFT_TRANSFER"
+}
+export type RandomNumberByTimestamp = {
+    timestamp: number;
+    randomNumber: number;
+};
+export type JettonBridgingData = RawAssetBridgingData & {
+    type: AssetType.FT;
+    address: string;
+};
+export type JettonTransferData = JettonBridgingData;
+export type JettonBurnData = JettonBridgingData & {
+    notificationReceiverAddress: string;
+};
+export type NFTBridgingData = RawAssetBridgingData & {
+    type: AssetType.NFT;
+    address: string;
+};
+export type NFTTransferData = NFTBridgingData & {
+    to: string;
+    responseAddress: string;
+    evmData: Cell;
+    crossChainTonAmount?: bigint;
+    feeData?: Cell;
+};
+export type NFTBurnData = NFTBridgingData & {
+    notificationReceiverAddress: string;
+    evmData: Cell;
+    crossChainTonAmount?: bigint;
+    feeData?: Cell;
+};
+export type InternalTONParams = {
+    contractOpener: ContractOpener;
+    jettonProxyAddress: string;
+    nftProxyAddress: string;
+    crossChainLayerAddress: string;
+    jettonMinterCode: Cell;
+    jettonWalletCode: Cell;
+    nftItemCode: Cell;
+    nftCollectionCode: Cell;
+};
+export type InternalTACParams = {
+    provider: AbstractProvider;
+    crossChainLayer: testnet.tac.wrappers.CrossChainLayerTAC | mainnet.tac.wrappers.CrossChainLayerTAC;
+    settings: testnet.tac.wrappers.SettingsTAC | testnet.tac.wrappers.SettingsTAC;
+    tokenUtils: testnet.tac.wrappers.TokenUtilsTAC | mainnet.tac.wrappers.TokenUtilsTAC;
+    trustedTACExecutors: string[];
+    trustedTONExecutors: string[];
+    abiCoder: ethers.AbiCoder;
+    crossChainLayerABI: Interface | InterfaceAbi;
+    crossChainLayerTokenABI: Interface | InterfaceAbi;
+    crossChainLayerTokenBytecode: string;
+    crossChainLayerNFTABI: Interface | InterfaceAbi;
+    crossChainLayerNFTBytecode: string;
+};
+export type ResponseBase<T> = {
+    response: T;
+};
+export type StringResponse = ResponseBase<string>;
+export type OperationTypeResponse = ResponseBase<OperationType>;
+export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
+export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
+export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
+export type TACSimulationResponse = ResponseBase<TACSimulationResult>;

package/dist/structs/InternalStruct.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetOpType = void 0;
+var AssetOpType;
+(function (AssetOpType) {
+    AssetOpType["JETTON_BURN"] = "JETTON_BURN";
+    AssetOpType["JETTON_TRANSFER"] = "JETTON_TRANSFER";
+    AssetOpType["NFT_BURN"] = "NFT_BURN";
+    AssetOpType["NFT_TRANSFER"] = "NFT_TRANSFER";
+})(AssetOpType || (exports.AssetOpType = AssetOpType = {}));