@tonappchain/sdk 0.7.0-rc24-test-9 → 0.7.0-rc24-test-10

package/dist/{structs → src/structs}/InternalStruct.d.ts

@@ -1,7 +1,8 @@
 import { Cell } from '@ton/ton';
-import { mainnet, testnet } from '@tonappchain/artifacts';
 import { AbstractProvider, ethers } from 'ethers';
-import { ContractOpener, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTONExecutorFee, TACSimulationResult } from './Struct';
+import { ICrossChainLayer, ISAFactory, ISettings, ITokenUtils } from '../../artifacts/tacTypes';
+import { ContractOpener } from '../interfaces';
+import { CurrencyType, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult } from './Struct';
 export type ShardMessage = {
     address: string;
     value: bigint;
@@ -34,13 +35,13 @@ export type InternalTONParams = {
 };
 export type InternalTACParams = {
     provider: AbstractProvider;
-    crossChainLayer: testnet.tac.wrappers.CrossChainLayerTAC | mainnet.tac.wrappers.CrossChainLayerTAC;
-    settings: testnet.tac.wrappers.SettingsTAC | mainnet.tac.wrappers.SettingsTAC;
-    tokenUtils: testnet.tac.wrappers.TokenUtilsTAC | mainnet.tac.wrappers.TokenUtilsTAC;
+    crossChainLayer: ICrossChainLayer;
+    settings: ISettings;
+    tokenUtils: ITokenUtils;
+    smartAccountFactory: ISAFactory;
     trustedTACExecutors: string[];
     trustedTONExecutors: string[];
     abiCoder: ethers.AbiCoder;
-    smartAccountFactory: testnet.tac.wrappers.TacSAFactoryTAC | mainnet.tac.wrappers.TacSAFactoryTAC;
 };
 export type ResponseBase<T> = {
     response: T;
@@ -51,7 +52,8 @@ export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
 export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
 export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
 export type TACSimulationResponse = ResponseBase<TACSimulationResult>;
-export type SuggestedTONExecutorFeeResponse = ResponseBase<SuggestedTONExecutorFee>;
+export type SuggestedTVMExecutorFeeResponse = ResponseBase<SuggestedTVMExecutorFee>;
+export type ConvertCurrencyResponse = ResponseBase<ConvertedCurrencyRawResult>;
 export interface SendResult {
     success: boolean;
     result?: unknown;
@@ -76,6 +78,9 @@ export type ToncenterTransaction = {
         hash: string;
         opcode: string;
     };
+    outMsgs: {
+        hash: string;
+    }[];
 };
 export type TransactionDepth = {
     hash: string;
@@ -91,3 +96,16 @@ export type TxFinalizerConfig = {
         value: string;
     };
 };
+export type USDPriceInfoRaw = {
+    spot: string;
+    ema: string;
+    decimals: number;
+};
+export type ConvertedCurrencyRawResult = {
+    spotValue: string;
+    emaValue: string;
+    decimals: number;
+    currency: CurrencyType;
+    tacPrice: USDPriceInfoRaw;
+    tonPrice: USDPriceInfoRaw;
+};

package/dist/{structs → src/structs}/Struct.d.ts

@@ -1,17 +1,14 @@
 import { SandboxContract } from '@ton/sandbox';
-import type { Address, Cell, Contract, OpenedContract } from '@ton/ton';
+import { OpenedContract } from '@ton/ton';
 import { AbstractProvider, Addressable } from 'ethers';
-import { ILogger } from './Services';
+import { JettonMinter, JettonMinterData } from '../../artifacts/tonTypes';
+import type { FT, NFT } from '../assets';
+import type { Asset, ContractOpener, ILogger } from '../interfaces';
 export type ContractState = {
     balance: bigint;
     state: 'active' | 'uninitialized' | 'frozen';
     code: Buffer | null;
 };
-export interface ContractOpener {
-    open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
-    getContractState(address: Address): Promise<ContractState>;
-    closeConnections?: () => unknown;
-}
 export declare enum SimplifiedStatuses {
     PENDING = "PENDING",
     FAILED = "FAILED",
@@ -20,12 +17,17 @@ export declare enum SimplifiedStatuses {
 }
 export declare enum Network {
     TESTNET = "testnet",
-    MAINNET = "mainnet"
+    MAINNET = "mainnet",
+    DEV = "dev"
 }
 export declare enum BlockchainType {
     TAC = "TAC",
     TON = "TON"
 }
+export declare enum CurrencyType {
+    TAC = "TAC",
+    TON = "TON"
+}
 export declare enum OperationType {
     PENDING = "PENDING",
     TON_TAC_TON = "TON-TAC-TON",
@@ -109,22 +111,25 @@ export type TransactionLinker = {
 export type TransactionLinkerWithOperationId = TransactionLinker & {
     operationId?: string;
 };
-export type TACSimulationRequest = {
-    tacCallParams: {
-        arguments: string;
-        methodName: string;
-        target: string;
-    };
-    evmValidExecutors: string[];
-    tvmValidExecutors: string[];
-    extraData: string;
+export type TONAsset = {
+    amount: string;
+    tokenAddress: string;
+    assetType: AssetType;
+};
+export type TACCallParams = {
+    arguments: string;
+    methodName: string;
+    target: string;
+};
+export type TACSimulationParams = {
+    tacCallParams: TACCallParams;
+    evmValidExecutors?: string[];
+    tvmValidExecutors?: string[];
+    extraData?: string;
     shardsKey: string;
-    tonAssets: {
-        amount: string;
-        tokenAddress: string;
-        assetType: string;
-    }[];
+    tonAssets: TONAsset[];
     tonCaller: string;
+    calculateRollbackFee?: boolean;
 };
 export declare enum StageName {
     COLLECTED_IN_TAC = "collectedInTAC",
@@ -204,8 +209,8 @@ export type MetaInfo = {
     initialCaller: InitialCallerInfo;
     validExecutors: ValidExecutors;
     feeInfo: FeeInfo;
-    sentAssets: AssetMovementInfo;
-    receivedAssets: AssetMovementInfo;
+    sentAssets: AssetMovementInfo | null;
+    receivedAssets: AssetMovementInfo | null;
 };
 export type ExecutionStages = {
     operationType: OperationType;
@@ -260,7 +265,7 @@ export type TACSimulationResult = {
         blockNumber: number;
     };
 };
-export type SuggestedTONExecutorFee = {
+export type SuggestedTVMExecutorFee = {
     inTAC: string;
     inTON: string;
 };
@@ -279,6 +284,9 @@ export type CrossChainTransactionOptions = {
     evmExecutorFee?: bigint;
     tvmValidExecutors?: string[];
     tvmExecutorFee?: bigint;
+    calculateRollbackFee?: boolean;
+    withoutSimulation?: boolean;
+    validateAssetsBalance?: boolean;
 };
 export type ExecutionFeeEstimationResult = {
     feeParams: FeeParams;
@@ -289,14 +297,26 @@ export type CrosschainTx = {
     assets?: Asset[];
     options?: CrossChainTransactionOptions;
 };
-export type NFTItemData = {
-    init: boolean;
-    index: number;
-    collectionAddress: Address;
-    ownerAddress: Address | null;
-    content: Cell | null;
+export type AssetLike = Asset | FT | NFT | {
+    rawAmount: bigint;
+} | {
+    amount: number;
+} | {
+    address: TVMAddress | EVMAddress;
+} | {
+    address: TVMAddress | EVMAddress;
+    rawAmount: bigint;
+} | {
+    address: TVMAddress | EVMAddress;
+    amount: number;
+} | {
+    address: TVMAddress | EVMAddress;
+    itemIndex: bigint;
+};
+export type CrosschainTxWithAssetLike = Omit<CrosschainTx, 'assets'> & {
+    assets?: AssetLike[];
 };
-export interface WaitOptions<T = unknown> {
+export interface WaitOptions<T = unknown, TContext = unknown> {
     /**
      * Timeout in milliseconds
      * @default 300000 (5 minutes)
@@ -316,40 +336,23 @@ export interface WaitOptions<T = unknown> {
      * Logger
      */
     logger?: ILogger;
+    /**
+     * Optional context object to pass additional parameters to callbacks
+     * This allows passing custom data like OperationTracker instances, configurations, etc.
+     */
+    context?: TContext;
     /**
      * Function to check if the result is successful
      * If not provided, any non-error result is considered successful
      */
-    successCheck?: (result: T) => boolean;
+    successCheck?: (result: T, context?: TContext) => boolean;
+    /**
+     * Custom callback function that executes when request is successful
+     * Receives both the result and optional context with additional parameters
+     */
+    onSuccess?: (result: T, context?: TContext) => Promise<void> | void;
 }
 export declare const defaultWaitOptions: WaitOptions;
-export interface Asset {
-    address: string;
-    type: AssetType;
-    rawAmount: bigint;
-    clone: Asset;
-    withAmount(amount: {
-        rawAmount: bigint;
-    } | {
-        amount: number;
-    }): Promise<Asset>;
-    addAmount(amount: {
-        rawAmount: bigint;
-    } | {
-        amount: number;
-    }): Promise<Asset>;
-    getEVMAddress(): Promise<string>;
-    getTVMAddress(): Promise<string>;
-    generatePayload(params: {
-        excessReceiver: string;
-        evmData: Cell;
-        crossChainTonAmount?: bigint;
-        forwardFeeTonAmount?: bigint;
-        feeParams?: FeeParams;
-    }): Promise<Cell>;
-    checkCanBeTransferedBy(userAddress: string): Promise<void>;
-    getBalanceOf(userAddress: string): Promise<bigint>;
-}
 export declare enum Origin {
     TON = "TON",
     TAC = "TAC"
@@ -371,3 +374,31 @@ export type AssetFromNFTItemArg = {
     tokenType: AssetType.NFT;
     addressType: NFTAddressType.ITEM;
 };
+export type ConvertCurrencyParams = {
+    value: bigint;
+    currency: CurrencyType;
+};
+export type USDPriceInfo = {
+    spot: bigint;
+    ema: bigint;
+    decimals: number;
+};
+export type ConvertedCurrencyResult = {
+    spotValue: bigint;
+    emaValue: bigint;
+    decimals: number;
+    currency: CurrencyType;
+    tacPrice: USDPriceInfo;
+    tonPrice: USDPriceInfo;
+};
+export type GetTVMExecutorFeeParams = {
+    feeSymbol: string;
+    tonAssets: TONAsset[];
+    tvmValidExecutors: string[];
+};
+export type FTOriginAndData = {
+    origin: Origin;
+    jettonMinter: OpenedContract<JettonMinter> | SandboxContract<JettonMinter>;
+    evmAddress?: string;
+    jettonData?: JettonMinterData;
+};

package/dist/{structs → src/structs}/Struct.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Origin = exports.defaultWaitOptions = exports.TokenSymbol = exports.StageName = exports.NFTAddressType = exports.AssetType = exports.OperationType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
+exports.Origin = exports.defaultWaitOptions = exports.TokenSymbol = exports.StageName = exports.NFTAddressType = exports.AssetType = exports.OperationType = exports.CurrencyType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
 var SimplifiedStatuses;
 (function (SimplifiedStatuses) {
     SimplifiedStatuses["PENDING"] = "PENDING";
@@ -12,12 +12,18 @@ var Network;
 (function (Network) {
     Network["TESTNET"] = "testnet";
     Network["MAINNET"] = "mainnet";
+    Network["DEV"] = "dev";
 })(Network || (exports.Network = Network = {}));
 var BlockchainType;
 (function (BlockchainType) {
     BlockchainType["TAC"] = "TAC";
     BlockchainType["TON"] = "TON";
 })(BlockchainType || (exports.BlockchainType = BlockchainType = {}));
+var CurrencyType;
+(function (CurrencyType) {
+    CurrencyType["TAC"] = "TAC";
+    CurrencyType["TON"] = "TON";
+})(CurrencyType || (exports.CurrencyType = CurrencyType = {}));
 var OperationType;
 (function (OperationType) {
     OperationType["PENDING"] = "PENDING";

package/dist/{wrappers → src/wrappers}/ContentUtils.js

@@ -1,5 +1,4 @@
 "use strict";
-// noinspection TypeScriptValidateTypes
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

package/dist/{wrappers → src/wrappers}/HighloadWalletV3.d.ts

@@ -1,5 +1,5 @@
 import { Address, Cell, ContractProvider, MessageRelaxed, OutAction, OutActionSendMsg, SendMode } from '@ton/ton';
-import { WalletInstance } from '../sender';
+import { WalletInstanse } from '../interfaces';
 import { HighloadQueryId } from './HighloadQueryId';
 export declare enum OP {
     InternalTransfer = 2923619748
@@ -14,7 +14,7 @@ export declare const DEFAULT_TIMEOUT: number;
 export declare const TIMESTAMP_SIZE = 64;
 export declare const TIMEOUT_SIZE = 22;
 export declare function highloadWalletV3ConfigToCell(config: HighloadWalletV3Config): Cell;
-export declare class HighloadWalletV3 implements WalletInstance {
+export declare class HighloadWalletV3 implements WalletInstanse {
     readonly address: Address;
     readonly init?: {
         code: Cell;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonappchain/sdk",
-  "version": "0.7.0-rc24-test-9",
+  "version": "0.7.0-rc24-test-10",
   "repository": "https://github.com/TacBuild/tac-sdk.git",
   "author": "TAC. <developers@tac>",
   "license": "MIT",

package/dist/errors/index.d.ts

@@ -1,2 +0,0 @@
-export { AddressError, BitError, ContractError, EVMCallError, FetchError, FormatError, KeyError, MetadataError, SettingError, TokenError, WalletError, } from './errors';
-export { allEndpointsFailedError, emptyArrayError, emptyContractError, emptySettingError, evmAddressError, indexRequiredError, insufficientBalanceError, invalidMethodNameError, notMultiplyOf8Error, operationFetchError, prefixError, profilingFetchError, simulationError, statusFetchError, tvmAddressError, unknownTokenTypeError, unknownWalletError, unsupportedFormatError, unsupportedKeyError, } from './instances';

package/dist/index.d.ts

@@ -1,19 +0,0 @@
-export { liteClientOpener, orbsOpener } from './adapters/contractOpener';
-export * from './errors';
-export { Configuration } from './sdk/Configuration';
-export { LiteSequencerClient } from './sdk/LiteSequencerClient';
-export { ConsoleLogger, NoopLogger } from './sdk/Logger';
-export { OperationTracker } from './sdk/OperationTracker';
-export { Simulator } from './sdk/Simulator';
-export { startTracking, startTrackingMultiple } from './sdk/StartTracking';
-export { TacSdk } from './sdk/TacSdk';
-export { TransactionManager } from './sdk/TransactionManager';
-export * from './sender';
-export * from './structs/Services';
-export * from './structs/Struct';
-export { Network, SimplifiedStatuses } from './structs/Struct';
-export * from './assets';
-export { readJettonMetadata } from './wrappers/ContentUtils';
-export { HighloadWalletV3 } from './wrappers/HighloadWalletV3';
-export type { JettonWalletData } from './wrappers/JettonWallet';
-export { JettonWallet, JettonWalletOpCodes } from './wrappers/JettonWallet';

package/dist/sdk/Configuration.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Configuration = void 0;
-const ton_1 = require("@ton/ton");
-const artifacts_1 = require("@tonappchain/artifacts");
-const ethers_1 = require("ethers");
-const retryableContractOpener_1 = require("../adapters/retryableContractOpener");
-const Struct_1 = require("../structs/Struct");
-const Settings_1 = require("../wrappers/Settings");
-const Validator_1 = require("./Validator");
-class Configuration {
-    constructor(network, artifacts, TONParams, TACParams, liteSequencerEndpoints) {
-        this.network = network;
-        this.artifacts = artifacts;
-        this.TONParams = TONParams;
-        this.TACParams = TACParams;
-        this.liteSequencerEndpoints = liteSequencerEndpoints;
-    }
-    static async create(network, artifacts, TONParams, TACParams, customLiteSequencerEndpoints, delay) {
-        const internalTONParams = await this.prepareTONParams(artifacts, TONParams, delay);
-        const internalTACParams = await this.prepareTACParams(artifacts, TACParams);
-        const liteSequencerEndpoints = customLiteSequencerEndpoints ??
-            (network === Struct_1.Network.TESTNET
-                ? artifacts_1.testnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS
-                : artifacts_1.mainnet.PUBLIC_LITE_SEQUENCER_ENDPOINTS);
-        return new Configuration(network, artifacts, internalTONParams, internalTACParams, liteSequencerEndpoints);
-    }
-    static async prepareTONParams(artifacts, TONParams, delay) {
-        const contractOpener = TONParams?.contractOpener ?? (await (0, retryableContractOpener_1.createDefaultRetryableOpener)(artifacts, 3, delay));
-        const settingsAddress = TONParams?.settingsAddress ?? artifacts.TON_SETTINGS_ADDRESS;
-        const settings = contractOpener.open(new Settings_1.Settings(ton_1.Address.parse(settingsAddress)));
-        const jettonProxyAddress = await settings.getAddressSetting('JettonProxyAddress');
-        const crossChainLayerAddress = await settings.getAddressSetting('CrossChainLayerAddress');
-        const jettonMinterCode = await settings.getCellSetting('JettonMinterCode');
-        const jettonWalletCode = await settings.getCellSetting('JettonWalletCode');
-        const nftProxyAddress = await settings.getAddressSetting('NFTProxyAddress');
-        const nftItemCode = await settings.getCellSetting('NFTItemCode');
-        const nftCollectionCode = await settings.getCellSetting('NFTCollectionCode');
-        return {
-            contractOpener,
-            jettonProxyAddress,
-            crossChainLayerAddress,
-            jettonMinterCode,
-            jettonWalletCode,
-            nftProxyAddress,
-            nftItemCode,
-            nftCollectionCode,
-        };
-    }
-    static async prepareTACParams(artifacts, TACParams) {
-        const provider = TACParams?.provider ?? ethers_1.ethers.getDefaultProvider(artifacts.TAC_RPC_ENDPOINT);
-        const settingsAddress = TACParams?.settingsAddress?.toString() ?? artifacts.TAC_SETTINGS_ADDRESS;
-        Validator_1.Validator.validateEVMAddress(settingsAddress);
-        const settings = artifacts.tac.wrappers.SettingsFactoryTAC.connect(settingsAddress, provider);
-        const crossChainLayerAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('CrossChainLayerAddress')));
-        const crossChainLayer = artifacts.tac.wrappers.CrossChainLayerFactoryTAC.connect(crossChainLayerAddress, provider);
-        const tokenUtilsAddress = await settings.getAddressSetting((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)('TokenUtilsAddress')));
-        const tokenUtils = artifacts.tac.wrappers.TokenUtilsFactoryTAC.connect(tokenUtilsAddress, provider);
-        const trustedTACExecutors = await settings.getTrustedEVMExecutors();
-        const trustedTONExecutors = await settings.getTrustedTVMExecutors();
-        const smartAccountFactory = artifacts.tac.wrappers.TacSAFactory_factoryTAC.connect(artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS, provider);
-        return {
-            provider,
-            settings,
-            tokenUtils,
-            crossChainLayer,
-            trustedTACExecutors,
-            trustedTONExecutors,
-            abiCoder: new ethers_1.ethers.AbiCoder(),
-            smartAccountFactory,
-        };
-    }
-    get nativeTONAddress() {
-        return 'NONE';
-    }
-    async nativeTACAddress() {
-        return this.TACParams.crossChainLayer.NATIVE_TOKEN_ADDRESS.staticCall();
-    }
-    get getTrustedTACExecutors() {
-        return this.TACParams.trustedTACExecutors;
-    }
-    get getTrustedTONExecutors() {
-        return this.TACParams.trustedTONExecutors;
-    }
-    closeConnections() {
-        return this.TONParams.contractOpener.closeConnections?.();
-    }
-    async isContractDeployedOnTVM(address) {
-        return (await this.TONParams.contractOpener.getContractState(ton_1.Address.parse(address))).state === 'active';
-    }
-}
-exports.Configuration = Configuration;

package/dist/sdk/LiteSequencerClient.d.ts

@@ -1,13 +0,0 @@
-import { ExecutionStagesByOperationId, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, TransactionLinker } from '../structs/Struct';
-export declare class LiteSequencerClient {
-    private readonly endpoint;
-    private readonly maxChunkSize;
-    constructor(endpoint: string, maxChunkSize?: number);
-    getOperationIdByTransactionHash(transactionHash: string): Promise<string>;
-    getOperationType(operationId: string): Promise<OperationType>;
-    getOperationId(transactionLinker: TransactionLinker): Promise<string>;
-    getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, chunkSize?: number): Promise<OperationIdsByShardsKey>;
-    getStageProfilings(operationIds: string[], chunkSize?: number): Promise<ExecutionStagesByOperationId>;
-    getOperationStatuses(operationIds: string[], chunkSize?: number): Promise<StatusInfosByOperationId>;
-    private processChunkedRequest;
-}

package/dist/sdk/Simulator.d.ts

@@ -1,23 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import type { SenderAbstraction } from '../sender';
-import { IConfiguration, ILogger, ISimulator } from '../structs/Services';
-import { Asset, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker } from '../structs/Struct';
-export interface IHttpClient {
-    post<T>(url: string, data: unknown, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
-}
-export declare class AxiosHttpClient implements IHttpClient {
-    post<T>(url: string, data: unknown, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
-}
-export declare class Simulator implements ISimulator {
-    private readonly config;
-    private readonly logger;
-    private readonly httpClient;
-    constructor(config: IConfiguration, logger?: ILogger, httpClient?: IHttpClient);
-    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
-    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
-    private buildTACSimulationRequest;
-    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
-    private getFeeInfo;
-    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
-    getSimulationInfoForTransaction(evmProxyMsg: EvmProxyMsg, transactionLinker: TransactionLinker, assets: Asset[], allowSimulationError?: boolean, isRoundTrip?: boolean, evmValidExecutors?: string[], tvmValidExecutors?: string[]): Promise<ExecutionFeeEstimationResult>;
-}