@tonappchain/sdk 0.7.2 → 0.7.3-rc2

package/dist/src/sdk/TacSdk.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacSdk = void 0;
+const ton_1 = require("@ton/ton");
 const artifacts_1 = require("../../artifacts");
+const adapters_1 = require("../adapters");
 const assets_1 = require("../assets");
+const errors_1 = require("../errors");
 const Struct_1 = require("../structs/Struct");
 const Configuration_1 = require("./Configuration");
 const Consts_1 = require("./Consts");
@@ -14,7 +17,7 @@ const TACTransactionManager_1 = require("./TACTransactionManager");
 const TONTransactionManager_1 = require("./TONTransactionManager");
 const Utils_1 = require("./Utils");
 class TacSdk {
-    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient) {
+    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient, tonIndexer) {
         this.config = config;
         this.contactOpener = config.TONParams.contractOpener;
         this.simulator = simulator;
@@ -22,6 +25,7 @@ class TacSdk {
         this.tacTransactionManager = tacTransactionManager;
         this.operationTracker = operationTracker;
         this.explorerClient = explorerClient;
+        this.tonIndexer = tonIndexer;
     }
     static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
         const network = sdkParams.network;
@@ -47,7 +51,8 @@ class TacSdk {
         const simulator = new Simulator_1.Simulator(config, operationTracker, logger);
         const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger);
         const tacTransactionManager = new TACTransactionManager_1.TACTransactionManager(config, operationTracker, logger);
-        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient);
+        const tonIndexer = sdkParams.TONParams?.tonIndexer ?? new adapters_1.ToncenterV3Indexer(artifacts.TONCENTER_V3_INDEXER_ENDPOINT);
+        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient, tonIndexer);
     }
     closeConnections() {
         return this.config.closeConnections();
@@ -87,6 +92,10 @@ class TacSdk {
         const tx = { evmProxyMsg, assets: normalizedAssets, options };
         return this.tonTransactionManager.sendCrossChainTransaction(evmProxyMsg, sender, tx);
     }
+    async sendCrossChainTransactionToTON(signer, tonTarget, assets, options) {
+        const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
+        return this.tacTransactionManager.sendCrossChainTransactionToTON(signer, tonTarget, normalizedAssets, options);
+    }
     async sendCrossChainTransactions(sender, txs, options) {
         const normalizedTxs = await Promise.all(txs.map(async (tx) => ({
             evmProxyMsg: tx.evmProxyMsg,
@@ -95,6 +104,32 @@ class TacSdk {
         })));
         return this.tonTransactionManager.sendCrossChainTransactions(sender, normalizedTxs, options);
     }
+    async getOperationIdByTonTransactionHash(transactionHash, waitOptions) {
+        const cclTransaction = await this.tonIndexer.findCollectibleCrossChainLayerTransaction(transactionHash, this.config.TONParams.crossChainLayerAddress);
+        if (!cclTransaction) {
+            return '';
+        }
+        return this.operationTracker.getOperationIdByTonTransactionHash(this.toSequencerTonTransactionHash(cclTransaction), waitOptions);
+    }
+    async getOperationIdByTonTransactionBoc(boc, waitOptions) {
+        let message;
+        try {
+            message = (0, ton_1.loadMessage)(ton_1.Cell.fromBase64(boc).beginParse());
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : undefined;
+            throw (0, errors_1.invalidTonExternalMessageBocError)(reason);
+        }
+        if (message.info.type !== 'external-in') {
+            throw (0, errors_1.externalInMessageRequiredError)(message.info.type);
+        }
+        const destination = message.info.dest;
+        const transaction = await this.contactOpener.getTransactionByHash(ton_1.Address.parse(destination.toString()), (0, Utils_1.getNormalizedExtMessageHash)(message));
+        if (!transaction) {
+            return '';
+        }
+        return this.getOperationIdByTonTransactionHash(transaction.hash().toString('base64'), waitOptions);
+    }
     async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors) {
         const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
         return this.tacTransactionManager.bridgeTokensToTON(signer, value, tonTarget, normalizedAssets, tvmExecutorFee, tvmValidExecutors);
@@ -200,5 +235,8 @@ class TacSdk {
     getTonContractOpener() {
         return this.contactOpener;
     }
+    toSequencerTonTransactionHash(transaction) {
+        return `0x${(0, Utils_1.normalizeHashToHex)(transaction.hash)}`;
+    }
 }
 exports.TacSdk = TacSdk;

package/dist/src/sdk/Utils.d.ts

@@ -3,7 +3,7 @@ import { AbiCoder } from 'ethers';
 import type { FT, NFT, TON } from '../assets';
 import { Asset, IConfiguration } from '../interfaces';
 import { RandomNumberByTimestamp } from '../structs/InternalStruct';
-import { AssetLike, EvmProxyMsg, FeeParams, TONAsset, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
+import { AssetLike, EvmProxyMsg, ExecutionStages, FeeParams, TONAsset, TransactionLinker, ValidExecutors, WaitOptions } from '../structs/Struct';
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare function generateRandomNumber(interval: number): number;
 export declare function generateRandomNumberByTimestamp(): RandomNumberByTimestamp;
@@ -56,3 +56,4 @@ export declare function recurisivelyCollectCellStats(cell: Cell): {
     bits: number;
     cells: number;
 };
+export declare function isFinalProfiling(profilingData: ExecutionStages): boolean;

package/dist/src/sdk/Utils.js

@@ -25,6 +25,7 @@ exports.normalizeHashToHex = normalizeHashToHex;
 exports.getNormalizedExtMessageHash = getNormalizedExtMessageHash;
 exports.retry = retry;
 exports.recurisivelyCollectCellStats = recurisivelyCollectCellStats;
+exports.isFinalProfiling = isFinalProfiling;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const ton_crypto_1 = require("ton-crypto");
@@ -415,7 +416,7 @@ function decodeBase64Like(input) {
 }
 function getNormalizedExtMessageHash(message) {
     if (message.info.type !== 'external-in') {
-        throw new Error(`Message must be "external-in", got ${message.info.type}`);
+        throw (0, errors_1.externalInMessageRequiredError)(message.info.type);
     }
     const info = {
         ...message.info,
@@ -458,3 +459,6 @@ function recurisivelyCollectCellStats(cell) {
     }
     return { bits, cells };
 }
+function isFinalProfiling(profilingData) {
+    return (profilingData.operationType !== Struct_1.OperationType.PENDING && profilingData.operationType !== Struct_1.OperationType.UNKNOWN);
+}

package/dist/src/structs/InternalStruct.d.ts

@@ -2,7 +2,7 @@ import { Address, Cell } from '@ton/ton';
 import { AbstractProvider, ethers } from 'ethers';
 import { ICrossChainLayer, ISAFactory, ISettings, ITokenUtils } from '../../artifacts/tacTypes';
 import { ContractOpener } from '../interfaces';
-import { CurrencyType, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult } from './Struct';
+import { CurrencyType, ExecutionStagesByOperationId, ExecutionStagesV2ByOperationId, Network, OperationIdsByShardsKey, OperationType, OperationTypeV2Info, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult, ToncenterV3IndexedTransaction, TransactionLinker } from './Struct';
 export type ShardMessage = {
     address: string;
     value: bigint;
@@ -17,6 +17,14 @@ export type ShardTransaction = {
     messages: ShardMessage[];
     network: Network;
 };
+export type PreparedCrossChainTransaction = {
+    transaction: ShardTransaction;
+    transactionLinker: TransactionLinker;
+};
+export type PreparedBridgeTokensToTON = {
+    outMessagePayload: ethers.BytesLike;
+    totalValue: bigint;
+};
 export declare enum AssetOpType {
     JETTON_BURN = "JETTON_BURN",
     JETTON_TRANSFER = "JETTON_TRANSFER",
@@ -54,9 +62,11 @@ export type ResponseBase<T> = {
 };
 export type StringResponse = ResponseBase<string>;
 export type OperationTypeResponse = ResponseBase<OperationType>;
+export type OperationTypeV2Response = ResponseBase<OperationTypeV2Info>;
 export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
 export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
 export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
+export type StageProfilingV2Response = ResponseBase<ExecutionStagesV2ByOperationId>;
 export type TACSimulationResponse = ResponseBase<TACSimulationResult>;
 export type SuggestedTVMExecutorFeeResponse = ResponseBase<SuggestedTVMExecutorFee>;
 export type ConvertCurrencyResponse = ResponseBase<ConvertedCurrencyRawResult>;
@@ -64,7 +74,7 @@ export type OperationIdWithLogIndex = {
     operationId: string;
     logIndex: number;
 };
-export type OperationIdWithLogIndexResponse = ResponseBase<OperationIdWithLogIndex>;
+export type OperationIdWithLogIndexResponse = ResponseBase<OperationIdWithLogIndex[]>;
 export interface SendResult {
     success: boolean;
     boc: string;
@@ -72,6 +82,29 @@ export interface SendResult {
     error?: Error;
     lastMessageIndex?: number;
 }
+export type SendGroupTransferResult = string | {
+    result: string;
+};
+export type SendBatchTransferResult = string | void | {
+    result: string | void;
+};
+export type RetryableOperationResult<T> = {
+    success: boolean;
+    data?: T;
+    lastError?: Error;
+};
+export type MetadataPersistenceType = 'none' | 'onchain' | 'offchain_private_domain' | 'offchain_ipfs' | 'semichain_private_domain' | 'semichain_ipfs';
+export type OffchainMetadataResult<TMetadata = unknown> = {
+    metadata: TMetadata | null;
+    isIpfs: boolean;
+    contentUri: string;
+};
+export type ReadMetadataResult<TMetadata = unknown> = {
+    persistenceType: MetadataPersistenceType;
+    metadata: TMetadata | null;
+    contentUri?: string;
+    isJettonDeployerFaultyOnChainData?: boolean;
+};
 export type ToncenterTransaction = {
     description: {
         aborted: boolean;
@@ -104,6 +137,12 @@ export type TransactionDepth = {
 export type AdjacentTransactionsResponse = {
     transactions: ToncenterTransaction[];
 };
+export type TonAdjacentTransactionsResponse = {
+    transactions: ToncenterV3IndexedTransaction[];
+};
+export type ToncenterV3TransactionsResponse = {
+    transactions: ToncenterV3IndexedTransaction[];
+};
 export type TxFinalizerConfig = {
     urlBuilder: (hash: string) => string;
     authorization?: {

package/dist/src/structs/Struct.d.ts

@@ -3,7 +3,7 @@ import { Cell, OpenedContract } from '@ton/ton';
 import { AbstractProvider } from 'ethers';
 import { JettonMinter, JettonMinterData } from '../../artifacts/tonTypes';
 import type { FT, NFT } from '../assets';
-import type { Asset, ContractOpener, ILogger } from '../interfaces';
+import type { Asset, ContractOpener, ILogger, IToncenterV3Indexer } from '../interfaces';
 import { SendResult } from './InternalStruct';
 export type ContractState = {
     balance: bigint;
@@ -37,6 +37,11 @@ export declare enum OperationType {
     TAC_TON = "TAC-TON",
     UNKNOWN = "UNKNOWN"
 }
+export type OperationTypeV2 = OperationType.TON_TAC_TON | OperationType.TON_TAC | OperationType.TAC_TON;
+export declare enum OperationExecutionStatus {
+    SUCCESS = "success",
+    FAILED = "failed"
+}
 export type TACParams = {
     /**
      * Provider for TAC side. Use your own provider for tests or to increase ratelimit
@@ -56,6 +61,11 @@ export type TONParams = {
      * Provider for TON side. Use your own provider for tests or to increase ratelimit
      */
     contractOpener?: ContractOpener;
+    /**
+     * Indexed Toncenter v3 client used to resolve TON transaction context by hash.
+     * Use your own implementation for tests or custom indexed backends.
+     */
+    tonIndexer?: IToncenterV3Indexer;
     /**
      * Address of TON settings contract. Use only for tests.
      */
@@ -120,6 +130,16 @@ export type TransactionLinker = {
 export type TransactionLinkerWithOperationId = TransactionLinker & {
     operationId?: string;
 };
+export type TACCrossChainTransactionResult = {
+    /**
+     * Hash of the TAC transaction
+     */
+    txHash: string;
+    /**
+     * Crosschain operation id
+     */
+    operationId?: string;
+};
 export type TONAsset = {
     amount: string;
     tokenAddress: string;
@@ -167,6 +187,54 @@ export type StageData = {
 export type StatusInfo = StageData & {
     stage: StageName;
 };
+/**
+ * Indexed transaction returned by Toncenter v3 `/transactions` and `/adjacentTransactions` endpoints.
+ */
+export type ToncenterV3IndexedTransaction = {
+    /** Account address that owns the transaction. */
+    account: string;
+    /** Indexed TON transaction hash. */
+    hash: string;
+    /** Optional trace identifier returned by Toncenter v3. */
+    traceId?: string;
+    /** Incoming message of the indexed transaction, when present in the response. */
+    inMsg?: {
+        /** Message source address. */
+        source?: string | null;
+        /** Message destination address. */
+        destination?: string | null;
+        /** Opcode reported by Toncenter v3 for the incoming message. */
+        opcode?: string | null;
+        /** Raw message content returned by Toncenter v3. */
+        messageContent?: {
+            /** BOC-encoded message body in base64 form. */
+            body?: string | null;
+        } | null;
+    } | null;
+    /** Outgoing messages of the indexed transaction. */
+    outMsgs: Array<{
+        /** Message destination address. `null` means external outbound log message. */
+        destination?: string | null;
+        /** Raw message content returned by Toncenter v3. */
+        messageContent?: {
+            /** BOC-encoded message body in base64 form. */
+            body?: string | null;
+        } | null;
+    }>;
+};
+/**
+ * Traversal settings for indexed search through a linked TON transaction chain in Toncenter v3.
+ */
+export type ToncenterV3TraversalParams = {
+    /**
+     * Maximum traversal depth from the starting transaction in the linked TON transaction chain.
+     */
+    maxDepth?: number;
+    /**
+     * Maximum number of unique indexed transactions to inspect.
+     */
+    maxScannedTransactions?: number;
+};
 export type ProfilingStageData = {
     exists: boolean;
     stageData: StageData | null;
@@ -225,7 +293,19 @@ export type ExecutionStages = {
     operationType: OperationType;
     metaInfo: MetaInfo;
 } & Record<StageName, ProfilingStageData>;
+export type OperationTypeV2Info = {
+    operationType: OperationTypeV2;
+    finalized: boolean;
+};
+export type ExecutionStagesV2 = {
+    operationType: OperationTypeV2;
+    metaInfo: MetaInfo;
+    finalized: boolean;
+    status: OperationExecutionStatus;
+    rollback: boolean;
+} & Record<StageName, ProfilingStageData>;
 export type ExecutionStagesByOperationId = Record<string, ExecutionStages>;
+export type ExecutionStagesV2ByOperationId = Record<string, ExecutionStagesV2>;
 export type StatusInfosByOperationId = Record<string, StatusInfo>;
 export type OperationIds = {
     operationIds: string[];
@@ -288,35 +368,153 @@ export type FeeParams = {
 };
 export type evmDataBuilder = (transactionLinker: TransactionLinker, evmProxyMsg: EvmProxyMsg, validExecutors: ValidExecutors) => Cell;
 export type CrossChainTransactionOptions = {
+    /**
+     * Allows sending to continue even when TAC simulation returns an unsuccessful result.
+     * @default false
+     */
     allowSimulationError?: boolean;
     /**
-     * If true, ensures TON transaction execution is validated before waiting for operation id.
+     * If true, validates the initial TON transaction tree right after sending the external message.
+     * This checks that the outbound TON transaction was actually executed before the SDK starts
+     * waiting for cross-chain tracking data.
      * @default true
      */
     ensureTxExecuted?: boolean;
     /**
      * If true, validates explicitly provided fee params against suggested values.
+     * Disable only when you intentionally want to send with custom fees.
      * @default true
      */
     shouldValidateFees?: boolean;
+    /**
+     * Forces the SDK to treat the operation as round-trip TON -> TAC -> TON.
+     * When omitted, the SDK derives this automatically from simulation results and attached assets.
+     */
     isRoundTrip?: boolean;
+    /**
+     * Explicit override for the protocol fee included in the transaction.
+     * Normally this is taken from simulation or on-chain configuration.
+     */
     protocolFee?: bigint;
+    /**
+     * Optional whitelist of TAC-side executor addresses allowed to execute the TAC part of the operation.
+     * When omitted, trusted executors from SDK configuration are used.
+     */
     evmValidExecutors?: string[];
+    /**
+     * Explicit fee paid to the TAC-side executor.
+     * Normally this is filled from simulation unless you provide custom manual fee params.
+     */
     evmExecutorFee?: bigint;
+    /**
+     * Optional whitelist of TON-side executor addresses allowed to execute the TON part of the operation.
+     * When omitted, trusted executors from SDK configuration are used.
+     */
     tvmValidExecutors?: string[];
+    /**
+     * Explicit fee paid to the TON-side executor for round-trip operations.
+     * Required in manual mode when `withoutSimulation` is true and `isRoundTrip` is true.
+     */
     tvmExecutorFee?: bigint;
+    /**
+     * Controls whether rollback fee should be included in TAC simulation.
+     * Keep enabled unless you intentionally want estimation without rollback costs.
+     * @default true
+     */
     calculateRollbackFee?: boolean;
+    /**
+     * Skips simulation entirely and uses only manually provided fee params.
+     * In this mode you must provide `protocolFee`, `evmExecutorFee`, and `evmProxyMsg.gasLimit`.
+     * If `isRoundTrip` is true, `tvmExecutorFee` is also required.
+     * @default false
+     */
     withoutSimulation?: boolean;
+    /**
+     * If true, validates that the sender currently owns or holds enough assets before building
+     * the cross-chain transaction payloads.
+     * Disable only if you already validated balances externally or need to skip this network call.
+     * @default true
+     */
     validateAssetsBalance?: boolean;
+    /**
+     * If true, waits until the operation ID becomes available after sending the TON transaction.
+     * Disable when you only need the raw send result and do not want any tracker polling.
+     * @default true
+     */
     waitOperationId?: boolean;
+    /**
+     * Retry policy used while resolving the operation ID.
+     * Use this to control timeout, attempts, delay, logger, callbacks, and success criteria.
+     */
     waitOptions?: WaitOptions<string>;
+    /**
+     * If true, waits for full cross-chain finalization after the operation ID is known:
+     * the SDK waits for a final operation type, fetches stage profiling, and validates
+     * TON transaction trees for `executedInTON` transactions when they exist.
+     * @default true
+     */
+    waitFinalization?: boolean;
+    /**
+     * Wait options used to finalize the cross-chain operation after operationId resolution.
+     * Use this to configure retries, delay, logger, successCheck, and onSuccess callback
+     * for stage profiling retrieval and post-processing.
+     */
+    finalizationWaitOptions?: WaitOptions<ExecutionStages>;
+    /**
+     * Custom builder for the EVM payload cell embedded into the TON message.
+     * Override only for advanced integrations that need non-standard TAC header encoding.
+     * By default the SDK uses `buildEvmDataCell`.
+     */
     evmDataBuilder?: evmDataBuilder;
 };
-export type BatchCrossChainTransactionOptions = Omit<CrossChainTransactionOptions, 'waitOperationId' | 'waitOptions' | 'ensureTxExecuted'>;
+export type BatchCrossChainTransactionOptions = Omit<CrossChainTransactionOptions, 'waitOperationId' | 'waitOptions' | 'ensureTxExecuted' | 'waitFinalization' | 'finalizationWaitOptions'>;
 export type CrossChainTransactionsOptions = {
     waitOperationIds?: boolean;
     waitOptions?: WaitOptions<OperationIdsByShardsKey>;
 };
+export type CrossChainTransactionToTONOptions = {
+    /**
+     * Optional explicit TON-side executor fee.
+     * When omitted, the SDK calls OperationTracker.getTVMExecutorFee().
+     */
+    tvmExecutorFee?: bigint;
+    /**
+     * Optional whitelist of allowed TVM executors.
+     * Used both for fee estimation and for the out message itself.
+     */
+    tvmValidExecutors?: string[];
+    /**
+     * If true, validates balances / ownership of non-native TAC assets before approvals and sending.
+     * Native TAC amount is still covered separately by the overall TAC balance sufficiency check.
+     * Disable only if you already validated balances externally or need to skip these RPC calls.
+     * @default true
+     */
+    validateAssetsBalance?: boolean;
+    /**
+     * If true, waits until the operation ID becomes available after sending the TON transaction.
+     * Disable when you only need the raw send result and do not want any tracker polling.
+     * @default true
+     */
+    waitOperationId?: boolean;
+    /**
+     * Retry policy used while resolving the operation ID.
+     * Use this to control timeout, attempts, delay, logger, callbacks, and success criteria.
+     */
+    waitOptions?: WaitOptions<string>;
+    /**
+     * Wait options used to finalize the cross-chain operation after operationId resolution.
+     * Use this to configure retries, delay, logger, successCheck, and onSuccess callback
+     * for stage profiling retrieval and post-processing.
+     */
+    waitFinalization?: boolean;
+    /**
+     * Wait options used to finalize the TAC->TON operation after operationId resolution.
+     * The SDK waits until the operation reaches a final operation type, fetches stage profiling,
+     * and, if profiling contains EXECUTED_IN_TON transactions, validates their TON transaction tree.
+     * This option is used only by sendCrossChainTransactionToTON and is ignored by bridgeTokensToTON.
+     */
+    finalizationWaitOptions?: WaitOptions<ExecutionStages>;
+};
 export type ExecutionFeeEstimationResult = {
     feeParams: FeeParams;
     simulation?: TACSimulationResult;
@@ -461,6 +659,11 @@ export type TacGasPrice = {
     fast: number;
     slow: number;
 };
+export declare enum TransactionTreeDirection {
+    FORWARD = "forward",
+    BACKWARD = "backward",
+    BOTH = "both"
+}
 /**
  * Parameters for tracking and validating transaction trees
  */
@@ -491,10 +694,10 @@ export type TrackTransactionTreeParams = {
      * Direction to search the transaction tree:
      * - 'forward': only search children (outgoing messages)
      * - 'backward': only search parents (incoming messages)
-     * - 'both': search in both directions (default)
-     * @default 'both'
+     * - 'both': search in both directions
+     * @default 'forward'
      */
-    direction?: 'forward' | 'backward' | 'both';
+    direction?: TransactionTreeDirection;
     /**
      * Retry transaction lookup when `not_found` error occurs.
      * Useful when transaction indexing has delays or when transactions appear gradually.

package/dist/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.CurrencyType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
+exports.TransactionTreeDirection = exports.Origin = exports.defaultWaitOptions = exports.TokenSymbol = exports.StageName = exports.NFTAddressType = exports.AssetType = exports.OperationExecutionStatus = exports.OperationType = exports.CurrencyType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
 const Consts_1 = require("../sdk/Consts");
 var SimplifiedStatuses;
 (function (SimplifiedStatuses) {
@@ -34,6 +34,11 @@ var OperationType;
     OperationType["TAC_TON"] = "TAC-TON";
     OperationType["UNKNOWN"] = "UNKNOWN";
 })(OperationType || (exports.OperationType = OperationType = {}));
+var OperationExecutionStatus;
+(function (OperationExecutionStatus) {
+    OperationExecutionStatus["SUCCESS"] = "success";
+    OperationExecutionStatus["FAILED"] = "failed";
+})(OperationExecutionStatus || (exports.OperationExecutionStatus = OperationExecutionStatus = {}));
 var AssetType;
 (function (AssetType) {
     AssetType["NFT"] = "NFT";
@@ -68,3 +73,9 @@ var Origin;
     Origin["TON"] = "TON";
     Origin["TAC"] = "TAC";
 })(Origin || (exports.Origin = Origin = {}));
+var TransactionTreeDirection;
+(function (TransactionTreeDirection) {
+    TransactionTreeDirection["FORWARD"] = "forward";
+    TransactionTreeDirection["BACKWARD"] = "backward";
+    TransactionTreeDirection["BOTH"] = "both";
+})(TransactionTreeDirection || (exports.TransactionTreeDirection = TransactionTreeDirection = {}));

package/dist/src/wrappers/ContentUtils.d.ts

@@ -1,25 +1,48 @@
 import { Cell } from '@ton/ton';
+import { MetadataPersistenceType } from '../structs/InternalStruct';
 export declare const ONCHAIN_CONTENT_PREFIX = 0;
 export declare const OFFCHAIN_CONTENT_PREFIX = 1;
-export interface JettonMetadata {
+export type JsonMetadataValue = string | number | boolean | null | JsonMetadataValue[] | {
+    [key: string]: JsonMetadataValue;
+};
+export type MetadataRecord<TKey extends string = string> = Partial<Record<TKey, JsonMetadataValue>> & {
+    [key: string]: JsonMetadataValue | undefined;
+};
+export type CommonMetadataKeys = 'uri' | 'name' | 'description' | 'image' | 'image_data';
+export type JettonMetaDataKeys = CommonMetadataKeys | 'symbol' | 'decimals' | 'amount_style' | 'render_type';
+export type NFTMetadataKeys = CommonMetadataKeys;
+export interface JettonMetadata extends MetadataRecord<JettonMetaDataKeys> {
     uri?: string;
-    name: string;
-    description: string;
+    name?: string;
+    description?: string;
     image?: string;
     image_data?: string;
-    symbol: string;
-    decimals?: string;
+    symbol?: string;
+    decimals?: string | number;
+    amount_style?: string;
+    render_type?: string;
 }
-export type JettonExtendedMetadata = {
-    persistenceType: persistenceType;
-    metadata: {
-        [s in JettonMetaDataKeys]?: string;
-    };
-    isJettonDeployerFaultyOnChainData?: boolean;
+export interface NFTMetadata extends MetadataRecord<NFTMetadataKeys> {
+    uri?: string;
+    name?: string;
+    description?: string;
+    image?: string;
+    image_data?: string;
+}
+type ExtendedMetadata<TKey extends string> = {
+    persistenceType: MetadataPersistenceType;
+    metadata: MetadataRecord<TKey> | null;
     contentUri?: string;
 };
+export type JettonExtendedMetadata = ExtendedMetadata<JettonMetaDataKeys> & {
+    isJettonDeployerFaultyOnChainData?: boolean;
+};
+export type NFTExtendedMetadata = ExtendedMetadata<NFTMetadataKeys>;
 export declare function buildJettonOffChainMetadata(contentUri: string): Cell;
-export type JettonMetaDataKeys = 'uri' | 'name' | 'description' | 'image' | 'symbol' | 'image_data' | 'decimals';
+export declare function buildNFTOffChainMetadata(contentUri: string): Cell;
 export declare function buildJettonOnchainMetadata(data: JettonMetadata): Cell;
-export type persistenceType = 'none' | 'onchain' | 'offchain_private_domain' | 'offchain_ipfs';
+export declare function buildNFTOnchainMetadata(data: NFTMetadata): Cell;
+export type persistenceType = MetadataPersistenceType;
 export declare function readJettonMetadata(contentCell: Cell): Promise<JettonExtendedMetadata>;
+export declare function readNFTMetadata(contentCell: Cell): Promise<NFTExtendedMetadata>;
+export {};