@tonappchain/sdk 0.5.7 → 0.6.1-spb.0.1

package/dist/sdk/Utils.d.ts

@@ -1,17 +1,17 @@
 import { Address, Cell } from '@ton/ton';
 import { AbiCoder } from 'ethers';
-import { EvmProxyMsg, TransactionLinker } from '../structs/Struct';
+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): Cell;
+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, l1Address: string): string;
+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;

package/dist/sdk/Utils.js

@@ -30,7 +30,7 @@ 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) {
+function buildEvmDataCell(transactionLinker, evmProxyMsg, validExecutors) {
     const evmArguments = evmProxyMsg.encodedParameters
         ? Buffer.from(evmProxyMsg.encodedParameters.split('0x')[1], 'hex').toString('base64')
         : null;
@@ -43,6 +43,8 @@ function buildEvmDataCell(transactionLinker, evmProxyMsg) {
         },
         shardsKey: transactionLinker.shardsKey,
         shardCount: transactionLinker.shardCount,
+        evmValidExecutors: validExecutors.tac,
+        tvmValidExecutors: validExecutors.ton,
     });
     return (0, ton_1.beginCell)().storeStringTail(json).endCell();
 }
@@ -76,8 +78,8 @@ function validateEVMAddress(address) {
         throw (0, errors_1.evmAddressError)(address);
     }
 }
-function calculateEVMTokenAddress(abiCoder, tokenUtilsAddress, crossChainLayerTokenBytecode, crossChainLayerAddress, l1Address) {
-    const salt = ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(['string'], [l1Address]));
+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);

package/dist/sender/RawSender.d.ts

@@ -6,6 +6,7 @@ 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

@@ -4,11 +4,44 @@ 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();
     }

package/dist/sender/SenderAbstraction.d.ts

@@ -15,5 +15,6 @@ export interface WalletInstance extends Contract {
 }
 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/TonConnectSender.d.ts

@@ -1,11 +1,12 @@
 import { TonConnectUI } from '@tonconnect/ui';
 import type { ShardTransaction } from '../structs/InternalStruct';
-import { Network } from '../structs/Struct';
+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

@@ -9,6 +9,28 @@ 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() || '';
     }

package/dist/structs/InternalStruct.d.ts

@@ -1,6 +1,7 @@
 import { Cell } from '@ton/ton';
-import { ContractOpener, TACSimulationResults, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, RawAssetBridgingData, StatusInfosByOperationId, OperationType } from './Struct';
+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;
@@ -13,35 +14,62 @@ export type ShardTransaction = {
 };
 export declare enum AssetOpType {
     JETTON_BURN = "JETTON_BURN",
-    JETTON_TRANSFER = "JETTON_TRANSFER"
+    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;
-    settingsAddress: string;
-    tokenUtilsAddress: string;
+    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;
-    crossChainLayerAddress: string;
     crossChainLayerTokenABI: Interface | InterfaceAbi;
     crossChainLayerTokenBytecode: string;
+    crossChainLayerNFTABI: Interface | InterfaceAbi;
+    crossChainLayerNFTBytecode: string;
 };
 export type ResponseBase<T> = {
     response: T;
@@ -51,4 +79,4 @@ export type OperationTypeResponse = ResponseBase<OperationType>;
 export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
 export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
 export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
-export type TACSimulationResponse = ResponseBase<TACSimulationResults>;
+export type TACSimulationResponse = ResponseBase<TACSimulationResult>;

package/dist/structs/InternalStruct.js

@@ -5,4 +5,6 @@ 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 = {}));

package/dist/structs/Struct.d.ts

@@ -1,5 +1,5 @@
 import { SandboxContract } from '@ton/sandbox';
-import type { Address, Contract, OpenedContract } from '@ton/ton';
+import type { Address, Cell, Contract, OpenedContract } from '@ton/ton';
 import { AbstractProvider, Addressable, Interface, InterfaceAbi } from 'ethers';
 export interface ContractOpener {
     open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
@@ -57,6 +57,14 @@ export type TACParams = {
      * bytecode of TAC CrossChainLayerToken contract. Use only for tests.
      */
     crossChainLayerTokenBytecode?: string;
+    /**
+     * ABI of TAC CrossChainLayerNFT contract. Use only for tests.
+     */
+    crossChainLayerNFTABI?: Interface | InterfaceAbi;
+    /**
+     * bytecode of TAC CrossChainLayerNFT contract. Use only for tests.
+     */
+    crossChainLayerNFTBytecode?: string;
 };
 export type TONParams = {
     /**
@@ -90,17 +98,46 @@ export type SDKParams = {
      */
     customLiteSequencerEndpoints?: string[];
 };
-export type WithAddress = {
+export declare enum AssetType {
+    NFT = "NFT",
+    FT = "FT"
+}
+export declare enum NFTAddressType {
+    ITEM = "ITEM",
+    COLLECTION = "COLLECTION"
+}
+export type WithAddressFT = {
+    type: AssetType.FT;
     /**
      * Address of TAC or TON token.
      * Empty if sending native TON coin.
      */
     address?: string;
 };
-export type RawAssetBridgingData = {
+export type WithAddressNFT_Item = {
+    type: AssetType.NFT;
+    /**
+     * Address NFT item token.
+     */
+    address: string;
+};
+export type WithAddressNFT_CollectionItem = {
+    type: AssetType.NFT;
+    /**
+     * Address NFT collection.
+     */
+    collectionAddress: string;
+    /**
+     * Index of NFT item in collection.
+     */
+    itemIndex: bigint;
+};
+export type WithAddressNFT = WithAddressNFT_Item | WithAddressNFT_CollectionItem;
+export type WithAddress = WithAddressFT | WithAddressNFT;
+export type RawAssetBridgingData<NFTFormatRequired extends WithAddressNFT = WithAddressNFT_Item> = {
     /** Raw format, e.g. 12340000000 (=12.34 tokens if decimals is 9) */
     rawAmount: bigint;
-} & WithAddress;
+} & (WithAddressFT | NFTFormatRequired);
 export type UserFriendlyAssetBridgingData = {
     /**
      * User friendly format, e.g. 12.34 tokens
@@ -142,12 +179,14 @@ export type TACSimulationRequest = {
         methodName: string;
         target: string;
     };
+    evmValidExecutors: string[];
     extraData: string;
     feeAssetAddress: string;
     shardsKey: string;
     tonAssets: {
         amount: string;
         tokenAddress: string;
+        assetType: string;
     }[];
     tonCaller: string;
 };
@@ -182,8 +221,35 @@ export type ProfilingStageData = {
     exists: boolean;
     stageData: StageData | null;
 };
+export type InitialCallerInfo = {
+    address: string;
+    blockchainType: BlockchainType;
+};
+export type ValidExecutors = {
+    tac: string[];
+    ton: string[];
+};
+export declare enum TokenSymbol {
+    TAC_SYMBOL = "TAC",
+    TON_SYMBOL = "TON"
+}
+export type GeneralFeeInfo = {
+    protocolFee: string;
+    executorFee: string;
+    tokenFeeSymbol: TokenSymbol;
+};
+export type FeeInfo = {
+    tac: GeneralFeeInfo;
+    ton: GeneralFeeInfo;
+};
+export type MetaInfo = {
+    initialCaller: InitialCallerInfo;
+    validExecutors: ValidExecutors;
+    feeInfo: FeeInfo;
+};
 export type ExecutionStages = {
     operationType: OperationType;
+    metaInfo: MetaInfo;
 } & Record<StageName, ProfilingStageData>;
 export type ExecutionStagesByOperationId = Record<string, ExecutionStages>;
 export type StatusInfosByOperationId = Record<string, StatusInfo>;
@@ -191,9 +257,8 @@ export type OperationIds = {
     operationIds: string[];
 };
 export type OperationIdsByShardsKey = Record<string, OperationIds>;
-export type TACSimulationResults = {
+export type TACSimulationResult = {
     estimatedGas: bigint;
-    estimatedJettonFeeAmount: string;
     feeParams: {
         currentBaseFee: string;
         isEip1559: boolean;
@@ -215,9 +280,19 @@ export type TACSimulationResults = {
             amount: string;
             tokenAddress: string;
         }[];
+        nftBurned: {
+            amount: string;
+            tokenAddress: string;
+        }[];
+        nftLocked: {
+            amount: string;
+            tokenAddress: string;
+        }[];
     }[] | null;
     simulationError: string;
     simulationStatus: boolean;
+    suggestedTonExecutionFee: string;
+    suggestedTacExecutionFee: string;
     debugInfo: {
         from: string;
         to: string;
@@ -225,3 +300,35 @@ export type TACSimulationResults = {
         blockNumber: number;
     };
 };
+export type FeeParams = {
+    isRoundTrip: boolean;
+    gasLimit: bigint;
+    protocolFee: bigint;
+    evmExecutorFee: bigint;
+    tvmExecutorFee: bigint;
+};
+export type CrossChainTransactionOptions = {
+    forceSend?: boolean;
+    isRoundTrip?: boolean;
+    protocolFee?: bigint;
+    evmValidExecutors?: string[];
+    evmExecutorFee?: bigint;
+    tvmValidExecutors?: string[];
+    tvmExecutorFee?: bigint;
+};
+export type ExecutionFeeEstimationResult = {
+    feeParams: FeeParams;
+    simulation: TACSimulationResult;
+};
+export type CrosschainTx = {
+    evmProxyMsg: EvmProxyMsg;
+    assets?: AssetBridgingData[];
+    options?: CrossChainTransactionOptions;
+};
+export type NFTItemData = {
+    init: boolean;
+    index: number;
+    collectionAddress: Address;
+    ownerAddress: Address | null;
+    content: Cell | null;
+};

package/dist/structs/Struct.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StageName = exports.OperationType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
+exports.TokenSymbol = exports.StageName = exports.NFTAddressType = exports.AssetType = exports.OperationType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
 var SimplifiedStatuses;
 (function (SimplifiedStatuses) {
     SimplifiedStatuses["PENDING"] = "PENDING";
@@ -27,6 +27,16 @@ var OperationType;
     OperationType["TAC_TON"] = "TAC-TON";
     OperationType["UNKNOWN"] = "UNKNOWN";
 })(OperationType || (exports.OperationType = OperationType = {}));
+var AssetType;
+(function (AssetType) {
+    AssetType["NFT"] = "NFT";
+    AssetType["FT"] = "FT";
+})(AssetType || (exports.AssetType = AssetType = {}));
+var NFTAddressType;
+(function (NFTAddressType) {
+    NFTAddressType["ITEM"] = "ITEM";
+    NFTAddressType["COLLECTION"] = "COLLECTION";
+})(NFTAddressType || (exports.NFTAddressType = NFTAddressType = {}));
 var StageName;
 (function (StageName) {
     StageName["COLLECTED_IN_TAC"] = "collectedInTAC";
@@ -36,3 +46,8 @@ var StageName;
     StageName["INCLUDED_IN_TON_CONSENSUS"] = "includedInTONConsensus";
     StageName["EXECUTED_IN_TON"] = "executedInTON";
 })(StageName || (exports.StageName = StageName = {}));
+var TokenSymbol;
+(function (TokenSymbol) {
+    TokenSymbol["TAC_SYMBOL"] = "TAC";
+    TokenSymbol["TON_SYMBOL"] = "TON";
+})(TokenSymbol || (exports.TokenSymbol = TokenSymbol = {}));

package/dist/wrappers/HighloadWalletV3.d.ts

@@ -42,7 +42,7 @@ export declare class HighloadWalletV3 implements WalletInstance {
         subwalletId: number;
         timeout: number;
     }): Promise<void>;
-    sendBatch(provider: ContractProvider, secretKey: Buffer, messages: OutActionSendMsg[], subwallet: number, queryId: HighloadQueryId, timeout: number, createdAt?: number, value?: bigint): Promise<void>;
+    sendBatch(provider: ContractProvider, secretKey: Buffer, messages: OutActionSendMsg[], subwallet: number, timeout: number, createdAt?: number, value?: bigint): Promise<void>;
     static createInternalTransferBody(opts: {
         actions: OutAction[] | Cell;
         queryId: HighloadQueryId;

package/dist/wrappers/HighloadWalletV3.js

@@ -38,13 +38,12 @@ class HighloadWalletV3 {
         const isActive = state.state.type === 'active';
         const subwalletId = isActive ? await this.getSubwalletId(provider) : exports.DEFAULT_SUBWALLET_ID;
         const timeout = isActive ? await this.getTimeout(provider) : exports.DEFAULT_TIMEOUT;
-        const queryId = new HighloadQueryId_1.HighloadQueryId();
         const actions = args.messages.map((msg) => ({
             type: 'sendMsg',
             mode: args.sendMode,
             outMsg: msg,
         }));
-        await this.sendBatch(provider, args.secretKey, actions, subwalletId, queryId, timeout);
+        await this.sendBatch(provider, args.secretKey, actions, subwalletId, timeout);
     }
     static create(config, code = HIGHLOAD_V3_CODE, workchain = 0) {
         const data = highloadWalletV3ConfigToCell(config);
@@ -72,10 +71,11 @@ class HighloadWalletV3 {
             .endCell();
         await provider.external((0, ton_1.beginCell)().storeBuffer((0, ton_crypto_1.sign)(messageInner.hash(), secretKey)).storeRef(messageInner).endCell());
     }
-    async sendBatch(provider, secretKey, messages, subwallet, queryId, timeout, createdAt, value = 0n) {
+    async sendBatch(provider, secretKey, messages, subwallet, timeout, createdAt, value = 0n) {
         if (createdAt == undefined) {
-            createdAt = Math.floor(Date.now() / 1000) - 20; // -20 is used to pass check created_at <= now() in smart contract for sure
+            createdAt = Math.floor(Date.now() / 1000) - 40; // -40 is used to pass check created_at <= now() in smart contract for sure
         }
+        const queryId = HighloadQueryId_1.HighloadQueryId.fromQueryId(BigInt(createdAt) % 8388608n);
         return await this.sendExternalMessage(provider, secretKey, {
             message: this.packActions(messages, value, queryId),
             mode: value > 0n ? ton_1.SendMode.PAY_GAS_SEPARATELY : ton_1.SendMode.CARRY_ALL_REMAINING_BALANCE,

package/dist/wrappers/JettonMaster.d.ts

@@ -20,5 +20,5 @@ export declare class JettonMaster implements Contract {
     constructor(address: Address);
     getWalletAddress(provider: ContractProvider, owner: string): Promise<string>;
     getJettonData(provider: ContractProvider): Promise<JettonMasterData>;
-    getL2Address(provider: ContractProvider): Promise<string>;
+    getEVMAddress(provider: ContractProvider): Promise<string>;
 }

package/dist/wrappers/JettonMaster.js

@@ -45,8 +45,8 @@ class JettonMaster {
             jettonWalletCode,
         };
     }
-    async getL2Address(provider) {
-        const result = await provider.get('get_l2_token_address', []);
+    async getEVMAddress(provider) {
+        const result = await provider.get('get_evm_token_address', []);
         return result.stack.readString();
     }
 }

package/dist/wrappers/JettonWallet.d.ts

@@ -23,15 +23,16 @@ export declare class JettonWallet implements Contract {
     } | undefined);
     static createFromAddress(address: Address): JettonWallet;
     static createFromConfig(config: JettonWalletData, code: Cell, workchain?: number): JettonWallet;
-    static burnMessage(jettonAmount: bigint, receiverAddress?: string, crossChainTonAmount?: bigint, crossChainPayload?: Cell | null, queryId?: number): Cell;
+    static burnMessage(jettonAmount: bigint, receiverAddress?: string, crossChainTonAmount?: bigint, feeData?: Cell | null, crossChainPayload?: Cell | null, queryId?: number): Cell;
     sendBurn(provider: ContractProvider, via: Sender, value: bigint, opts: {
         queryId?: number;
         jettonAmount: bigint;
         receiverAddress?: string;
         crossChainTonAmount?: bigint;
+        feeData?: Cell | null;
         crossChainPayload?: Cell | null;
     }): Promise<void>;
-    static transferMessage(jettonAmount: bigint, to: string, responseAddress: string | null, forwardTonAmount?: bigint, crossChainTonAmount?: bigint, crossChainPayload?: Cell | null, queryId?: number): Cell;
+    static transferMessage(jettonAmount: bigint, to: string, responseAddress: string | null, forwardTonAmount?: bigint, crossChainTonAmount?: bigint, feeData?: Cell | null, crossChainPayload?: Cell | null, queryId?: number): Cell;
     sendTransfer(provider: ContractProvider, via: Sender, value: bigint, opts: {
         queryId?: number;
         jettonAmount: bigint;

package/dist/wrappers/JettonWallet.js

@@ -28,7 +28,7 @@ class JettonWallet {
         const init = { code, data };
         return new JettonWallet((0, ton_1.contractAddress)(workchain, init), init);
     }
-    static burnMessage(jettonAmount, receiverAddress, crossChainTonAmount, crossChainPayload, queryId) {
+    static burnMessage(jettonAmount, receiverAddress, crossChainTonAmount, feeData, crossChainPayload, queryId) {
         const body = (0, ton_1.beginCell)()
             .storeUint(JettonWalletOpCodes.burn, 32)
             .storeUint(queryId || 0, 64)
@@ -37,6 +37,7 @@ class JettonWallet {
         if (crossChainTonAmount || crossChainPayload) {
             body.storeMaybeRef((0, ton_1.beginCell)()
                 .storeCoins(crossChainTonAmount ?? 0n)
+                .storeMaybeRef(feeData)
                 .storeMaybeRef(crossChainPayload)
                 .endCell());
         }
@@ -46,14 +47,14 @@ class JettonWallet {
         return body.endCell();
     }
     async sendBurn(provider, via, value, opts) {
-        const body = JettonWallet.burnMessage(opts.jettonAmount, opts.receiverAddress, opts.crossChainTonAmount, opts.crossChainPayload, opts.queryId);
+        const body = JettonWallet.burnMessage(opts.jettonAmount, opts.receiverAddress, opts.crossChainTonAmount, opts.feeData, opts.crossChainPayload, opts.queryId);
         await provider.internal(via, {
             value,
             sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
             body: body,
         });
     }
-    static transferMessage(jettonAmount, to, responseAddress, forwardTonAmount, crossChainTonAmount, crossChainPayload, queryId) {
+    static transferMessage(jettonAmount, to, responseAddress, forwardTonAmount, crossChainTonAmount, feeData, crossChainPayload, queryId) {
         return (0, ton_1.beginCell)()
             .storeUint(JettonWalletOpCodes.transfer, 32)
             .storeUint(queryId ?? 0, 64)
@@ -61,9 +62,12 @@ class JettonWallet {
             .storeAddress(ton_1.Address.parse(to))
             .storeAddress(responseAddress ? ton_1.Address.parse(responseAddress) : null)
             .storeMaybeRef(null)
-            .storeCoins((forwardTonAmount || 0n) + (crossChainTonAmount || 0n))
+            .storeCoins((forwardTonAmount || 0n))
+            .storeMaybeRef((0, ton_1.beginCell)()
             .storeCoins(crossChainTonAmount ?? 0n)
+            .storeMaybeRef(feeData)
             .storeMaybeRef(crossChainPayload)
+            .endCell())
             .endCell();
     }
     async sendTransfer(provider, via, value, opts) {