@tonappchain/sdk 0.7.2 → 0.7.3-rc1

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

@@ -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
@@ -120,6 +125,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;
@@ -225,7 +240,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 +315,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 BridgeTokensToTONOptions = {
+    /**
+     * 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 +606,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 +641,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 {};

package/dist/src/wrappers/ContentUtils.js

@@ -5,155 +5,254 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OFFCHAIN_CONTENT_PREFIX = exports.ONCHAIN_CONTENT_PREFIX = void 0;
 exports.buildJettonOffChainMetadata = buildJettonOffChainMetadata;
+exports.buildNFTOffChainMetadata = buildNFTOffChainMetadata;
 exports.buildJettonOnchainMetadata = buildJettonOnchainMetadata;
+exports.buildNFTOnchainMetadata = buildNFTOnchainMetadata;
 exports.readJettonMetadata = readJettonMetadata;
+exports.readNFTMetadata = readNFTMetadata;
 const sha256_js_1 = require("@aws-crypto/sha256-js");
 const ton_1 = require("@ton/ton");
 const axios_1 = __importDefault(require("axios"));
-const bn_js_1 = __importDefault(require("bn.js"));
 const errors_1 = require("../errors");
 exports.ONCHAIN_CONTENT_PREFIX = 0x00;
 exports.OFFCHAIN_CONTENT_PREFIX = 0x01;
-const SNAKE_PREFIX = 0x00;
-function buildJettonOffChainMetadata(contentUri) {
-    return (0, ton_1.beginCell)().storeInt(exports.OFFCHAIN_CONTENT_PREFIX, 8).storeBuffer(Buffer.from(contentUri, 'ascii')).endCell();
-}
-const jettonOnChainMetadataSpec = {
+const SNAKE_CONTENT_PREFIX = 0x00;
+const CHUNKED_CONTENT_PREFIX = 0x01;
+const CELL_MAX_BITS = 1023;
+const commonMetadataSpec = {
     uri: 'ascii',
     name: 'utf8',
     description: 'utf8',
     image: 'ascii',
     image_data: 'ascii',
+};
+const jettonOnChainMetadataSpec = {
+    ...commonMetadataSpec,
     symbol: 'utf8',
     decimals: 'utf8',
+    amount_style: 'utf8',
+    render_type: 'utf8',
 };
-const sha256 = (str) => {
+const nftOnChainMetadataSpec = {
+    ...commonMetadataSpec,
+};
+const sha256 = (value) => {
     const sha = new sha256_js_1.Sha256();
-    sha.update(str);
+    sha.update(value);
     return Buffer.from(sha.digestSync());
 };
-function storeSnakeContent(content, isFirst) {
-    const CELL_MAX_SIZE_BYTES = Math.floor((1023 - 8) / 8);
+function getAvailableBytes(withPrefix) {
+    return Math.floor((CELL_MAX_BITS - (withPrefix ? 8 : 0)) / 8);
+}
+function buildSnakeCell(content, withPrefix) {
     const cell = new ton_1.Builder();
-    if (isFirst) {
-        cell.storeUint(SNAKE_PREFIX, 8);
+    if (withPrefix) {
+        cell.storeUint(SNAKE_CONTENT_PREFIX, 8);
     }
-    cell.storeBuffer(content.subarray(0, CELL_MAX_SIZE_BYTES));
-    const remainingContent = content.subarray(CELL_MAX_SIZE_BYTES);
+    const bytesToStore = getAvailableBytes(withPrefix);
+    cell.storeBuffer(content.subarray(0, bytesToStore));
+    const remainingContent = content.subarray(bytesToStore);
     if (remainingContent.length > 0) {
-        cell.storeRef(storeSnakeContent(remainingContent, false));
+        cell.storeRef(buildSnakeCell(remainingContent, false));
     }
     return cell.endCell();
 }
-function buildJettonOnchainMetadata(data) {
-    const dict = ton_1.Dictionary.empty();
-    Object.entries(data).forEach(([k, v]) => {
-        if (!jettonOnChainMetadataSpec[k]) {
-            throw (0, errors_1.unsupportedKeyError)(k);
+function buildOffchainContent(contentUri) {
+    const content = Buffer.from(contentUri, 'ascii');
+    const root = (0, ton_1.beginCell)().storeUint(exports.OFFCHAIN_CONTENT_PREFIX, 8);
+    const bytesToStore = getAvailableBytes(true);
+    root.storeBuffer(content.subarray(0, bytesToStore));
+    const remainingContent = content.subarray(bytesToStore);
+    if (remainingContent.length > 0) {
+        root.storeRef(buildSnakeCell(remainingContent, false));
+    }
+    return root.endCell();
+}
+function ensureByteAligned(slice) {
+    if (slice.remainingBits % 8 !== 0) {
+        throw errors_1.notMultiplyOf8Error;
+    }
+}
+function readSnakeData(slice, withPrefix) {
+    if (withPrefix) {
+        if (slice.loadUint(8) !== SNAKE_CONTENT_PREFIX) {
+            throw errors_1.unsupportedFormatError;
         }
-        if (!v || v == '' || v == null) {
-            return;
+    }
+    ensureByteAligned(slice);
+    const current = slice.remainingBits > 0 ? slice.loadBuffer(slice.remainingBits / 8) : Buffer.alloc(0);
+    if (slice.remainingRefs === 0) {
+        return current;
+    }
+    if (slice.remainingRefs > 1) {
+        throw errors_1.unsupportedFormatError;
+    }
+    return Buffer.concat([current, readSnakeData(slice.loadRef().beginParse(), false)]);
+}
+function readChunkedData(slice) {
+    const dict = slice.loadDict(ton_1.Dictionary.Keys.Uint(32), ton_1.Dictionary.Values.Cell());
+    const chunks = dict.keys().sort((a, b) => a - b);
+    return Buffer.concat(chunks.map((chunkIndex) => {
+        const chunk = dict.get(chunkIndex);
+        if (!chunk) {
+            return Buffer.alloc(0);
         }
-        const bufferToStore = Buffer.from(v, jettonOnChainMetadataSpec[k]);
-        dict.set(sha256(k), storeSnakeContent(bufferToStore, true));
-    });
-    return (0, ton_1.beginCell)()
-        .storeInt(exports.ONCHAIN_CONTENT_PREFIX, 8)
-        .storeDict(dict, ton_1.Dictionary.Keys.Buffer(32), ton_1.Dictionary.Values.Cell())
-        .endCell();
+        return readSnakeData(chunk.beginParse(), true);
+    }));
 }
-function readSnakeContent(slice, isFirst) {
-    if (isFirst && slice.loadUint(8) !== SNAKE_PREFIX) {
-        throw errors_1.unsupportedFormatError;
+function readContentData(cell) {
+    const slice = cell.beginParse();
+    const prefix = slice.loadUint(8);
+    if (prefix === SNAKE_CONTENT_PREFIX) {
+        return readSnakeData(slice, false);
     }
-    if (slice.remainingBits % 8 !== 0) {
-        throw errors_1.notMultiplyOf8Error;
+    if (prefix === CHUNKED_CONTENT_PREFIX) {
+        return readChunkedData(slice);
     }
-    let remainingBytes = Buffer.from('');
-    if (slice.remainingBits != 0) {
-        remainingBytes = slice.loadBuffer(slice.remainingBits / 8);
-    }
-    if (slice.remainingRefs != 0) {
-        const newCell = slice.loadRef();
-        remainingBytes = Buffer.concat([remainingBytes, readSnakeContent(newCell.beginParse(), false)]);
-    }
-    return remainingBytes;
-}
-function parseJettonOnchainMetadata(contentSlice) {
-    // Note that this relies on what is (perhaps) an internal implementation detail:
-    // "sdk" library dict parser converts: key (provided as buffer) => BN(base10)
-    // and upon parsing, it reads it back to a BN(base10)
-    // tl;dr if we want to read the map back to a JSON with string keys, we have to convert BN(10) back to hex
-    const toKey = (str) => BigInt(new bn_js_1.default(str, 'hex').toString(10));
-    const isJettonDeployerFaultyOnChainData = false;
-    const cellDict = contentSlice.loadDict(ton_1.Dictionary.Keys.BigUint(256), ton_1.Dictionary.Values.Cell());
-    const dict = new Map();
-    cellDict.values().forEach((item, index) => {
-        dict.set(cellDict.keys()[index], readSnakeContent(item.beginParse(), true));
-    });
-    const res = {};
-    Object.keys(jettonOnChainMetadataSpec).forEach((k) => {
-        const val = dict
-            .get(toKey(sha256(k).toString('hex')))
-            ?.toString(jettonOnChainMetadataSpec[k]);
-        if (val) {
-            res[k] = val;
+    throw errors_1.unsupportedFormatError;
+}
+function parseOnchainMetadata(contentSlice, metadataSpec) {
+    const dict = contentSlice.loadDict(ton_1.Dictionary.Keys.Buffer(32), ton_1.Dictionary.Values.Cell());
+    const metadata = {};
+    for (const key of Object.keys(metadataSpec)) {
+        const encoding = metadataSpec[key];
+        if (!encoding) {
+            continue;
+        }
+        const cell = dict.get(sha256(key));
+        if (!cell) {
+            continue;
         }
-    });
+        const value = readContentData(cell).toString(encoding);
+        if (value) {
+            metadata[key] = value;
+        }
+    }
     return {
-        metadata: res,
-        isJettonDeployerFaultyOnChainData,
+        metadata,
+        isJettonDeployerFaultyOnChainData: false,
     };
 }
-async function parseJettonOffchainMetadata(contentSlice) {
-    const remainingBits = contentSlice.remainingBits;
-    if (remainingBits % 8 !== 0) {
-        throw errors_1.notMultiplyOf8Error;
+function normalizeContentUri(contentUri) {
+    if (contentUri.startsWith('ipfs://')) {
+        const ipfsPath = contentUri.slice('ipfs://'.length).replace(/^ipfs\//, '');
+        return {
+            contentUri: `https://ipfs.io/ipfs/${ipfsPath}`,
+            isIpfs: true,
+        };
     }
-    const jsonURI = contentSlice
-        .loadBuffer(remainingBits / 8)
-        .toString('ascii')
-        .replace('ipfs://', 'https://ipfs.io/ipfs/');
-    let metadata = null;
-    let isIpfs = null;
+    return {
+        contentUri,
+        isIpfs: /(^|\/)ipfs[.:/]/i.test(contentUri),
+    };
+}
+async function fetchOffchainMetadata(contentUri) {
+    const normalized = normalizeContentUri(contentUri);
     try {
-        metadata = (await axios_1.default.get(jsonURI)).data;
-        isIpfs = /(^|\/)ipfs[.:]/.test(jsonURI);
+        const response = await axios_1.default.get(normalized.contentUri);
+        const metadata = response.data && typeof response.data === 'object' && !Array.isArray(response.data)
+            ? response.data
+            : null;
+        return {
+            metadata,
+            isIpfs: normalized.isIpfs,
+            contentUri: normalized.contentUri,
+        };
     }
     catch {
-        // nothing
+        return {
+            metadata: null,
+            isIpfs: normalized.isIpfs,
+            contentUri: normalized.contentUri,
+        };
     }
-    return {
-        metadata,
-        isIpfs,
-        contentUri: jsonURI,
-    };
 }
-async function readJettonMetadata(contentCell) {
+async function parseOffchainMetadata(contentSlice) {
+    const contentUri = readSnakeData(contentSlice, false).toString('ascii');
+    return fetchOffchainMetadata(contentUri);
+}
+async function readMetadata(contentCell, metadataSpec) {
     if (contentCell.bits.length <= 0) {
         return {
             contentUri: undefined,
-            isJettonDeployerFaultyOnChainData: false,
             metadata: {},
             persistenceType: 'none',
         };
     }
     const contentSlice = contentCell.beginParse();
-    switch (contentSlice.loadUint(8)) {
-        case exports.ONCHAIN_CONTENT_PREFIX:
+    const prefix = contentSlice.loadUint(8);
+    if (prefix === exports.ONCHAIN_CONTENT_PREFIX) {
+        const { metadata: onchainMetadata, isJettonDeployerFaultyOnChainData } = parseOnchainMetadata(contentSlice, metadataSpec);
+        const uri = onchainMetadata.uri;
+        if (typeof uri === 'string' && uri.length > 0) {
+            const { metadata: offchainMetadata, isIpfs, contentUri } = await fetchOffchainMetadata(uri);
             return {
-                persistenceType: 'onchain',
-                ...parseJettonOnchainMetadata(contentSlice),
-            };
-        case exports.OFFCHAIN_CONTENT_PREFIX: {
-            const { metadata, isIpfs, contentUri } = await parseJettonOffchainMetadata(contentSlice);
-            return {
-                persistenceType: isIpfs ? 'offchain_ipfs' : 'offchain_private_domain',
                 contentUri,
-                metadata,
+                isJettonDeployerFaultyOnChainData,
+                metadata: {
+                    ...(offchainMetadata ?? {}),
+                    ...onchainMetadata,
+                },
+                persistenceType: isIpfs ? 'semichain_ipfs' : 'semichain_private_domain',
             };
         }
-        default:
-            throw errors_1.prefixError;
+        return {
+            isJettonDeployerFaultyOnChainData,
+            metadata: onchainMetadata,
+            persistenceType: 'onchain',
+        };
+    }
+    if (prefix === exports.OFFCHAIN_CONTENT_PREFIX) {
+        const { metadata, isIpfs, contentUri } = await parseOffchainMetadata(contentSlice);
+        return {
+            contentUri,
+            metadata,
+            persistenceType: isIpfs ? 'offchain_ipfs' : 'offchain_private_domain',
+        };
+    }
+    throw errors_1.prefixError;
+}
+function buildOnchainMetadata(data, metadataSpec) {
+    const dict = ton_1.Dictionary.empty(ton_1.Dictionary.Keys.Buffer(32), ton_1.Dictionary.Values.Cell());
+    for (const [key, value] of Object.entries(data)) {
+        const encoding = metadataSpec[key];
+        if (!encoding) {
+            throw (0, errors_1.unsupportedKeyError)(key);
+        }
+        if (value === '' || value == null) {
+            continue;
+        }
+        dict.set(sha256(key), buildSnakeCell(Buffer.from(String(value), encoding), true));
     }
+    return (0, ton_1.beginCell)()
+        .storeUint(exports.ONCHAIN_CONTENT_PREFIX, 8)
+        .storeDict(dict, ton_1.Dictionary.Keys.Buffer(32), ton_1.Dictionary.Values.Cell())
+        .endCell();
+}
+function buildJettonOffChainMetadata(contentUri) {
+    return buildOffchainContent(contentUri);
+}
+function buildNFTOffChainMetadata(contentUri) {
+    return buildOffchainContent(contentUri);
+}
+function buildJettonOnchainMetadata(data) {
+    return buildOnchainMetadata(data, jettonOnChainMetadataSpec);
+}
+function buildNFTOnchainMetadata(data) {
+    return buildOnchainMetadata(data, nftOnChainMetadataSpec);
+}
+async function readJettonMetadata(contentCell) {
+    const metadata = await readMetadata(contentCell, jettonOnChainMetadataSpec);
+    return {
+        ...metadata,
+        isJettonDeployerFaultyOnChainData: metadata.isJettonDeployerFaultyOnChainData ?? false,
+    };
+}
+async function readNFTMetadata(contentCell) {
+    const metadata = await readMetadata(contentCell, nftOnChainMetadataSpec);
+    return {
+        contentUri: metadata.contentUri,
+        metadata: metadata.metadata,
+        persistenceType: metadata.persistenceType,
+    };
 }