@tonappchain/sdk 0.7.0-rc8 → 0.7.0

package/dist/artifacts/tonTypes.d.ts

@@ -0,0 +1,20 @@
+import type * as Dev from './dev';
+import type * as Mainnet from './mainnet';
+import type * as Testnet from './testnet';
+export type MsgType = Dev.ton.wrappers.MsgType | Testnet.ton.wrappers.MsgType | Mainnet.ton.wrappers.MsgType;
+export type CrossChainLayer = Dev.ton.wrappers.CrossChainLayer | Testnet.ton.wrappers.CrossChainLayer | Mainnet.ton.wrappers.CrossChainLayer;
+export type CrossChainLayerData = Dev.ton.wrappers.CrossChainLayerConfig | Testnet.ton.wrappers.CrossChainLayerConfig | Mainnet.ton.wrappers.CrossChainLayerConfig;
+export type JettonMinter = Dev.ton.wrappers.JettonMinter | Testnet.ton.wrappers.JettonMinter | Mainnet.ton.wrappers.JettonMinter;
+export type JettonMinterData = Dev.ton.wrappers.JettonMinterData | Testnet.ton.wrappers.JettonMinterData | Mainnet.ton.wrappers.JettonMinterData;
+export type JettonWallet = Dev.ton.wrappers.JettonWallet | Testnet.ton.wrappers.JettonWallet | Mainnet.ton.wrappers.JettonWallet;
+export type JettonWalletData = Dev.ton.wrappers.JettonWalletData | Testnet.ton.wrappers.JettonWalletData | Mainnet.ton.wrappers.JettonWalletData;
+export type JettonProxy = Dev.ton.wrappers.JettonProxy | Testnet.ton.wrappers.JettonProxy | Mainnet.ton.wrappers.JettonProxy;
+export type JettonProxyData = Dev.ton.wrappers.JettonProxyConfig | Testnet.ton.wrappers.JettonProxyConfig | Mainnet.ton.wrappers.JettonProxyConfig;
+export type Settings = Dev.ton.wrappers.Settings | Testnet.ton.wrappers.Settings | Mainnet.ton.wrappers.Settings;
+export type SettingsData = Dev.ton.wrappers.SettingsConfig | Testnet.ton.wrappers.SettingsConfig | Mainnet.ton.wrappers.SettingsConfig;
+export type NFTCollection = Dev.ton.wrappers.NFTCollection | Testnet.ton.wrappers.NFTCollection | Mainnet.ton.wrappers.NFTCollection;
+export type NFTCollectionData = Dev.ton.wrappers.NFTCollectionData | Testnet.ton.wrappers.NFTCollectionData | Mainnet.ton.wrappers.NFTCollectionData;
+export type NFTItem = Dev.ton.wrappers.NFTItem | Testnet.ton.wrappers.NFTItem | Mainnet.ton.wrappers.NFTItem;
+export type NFTItemData = Dev.ton.wrappers.NFTItemData | Testnet.ton.wrappers.NFTItemData | Mainnet.ton.wrappers.NFTItemData;
+export type NFTProxy = Dev.ton.wrappers.NFTProxy | Testnet.ton.wrappers.NFTProxy | Mainnet.ton.wrappers.NFTProxy;
+export type NFTProxyData = Dev.ton.wrappers.NFTProxyConfig | Testnet.ton.wrappers.NFTProxyConfig | Mainnet.ton.wrappers.NFTProxyConfig;

package/dist/artifacts/tonTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{adapters → src/adapters}/contractOpener.d.ts

@@ -1,5 +1,6 @@
 import { Blockchain } from '@ton/sandbox';
-import { ContractOpener, Network } from '../structs/Struct';
+import { ContractOpener } from '../interfaces';
+import { Network } from '../structs/Struct';
 type LiteServer = {
     ip: number;
     port: number;

package/dist/{adapters → src/adapters}/contractOpener.js

@@ -6,9 +6,42 @@ exports.orbsOpener = orbsOpener;
 exports.orbsOpener4 = orbsOpener4;
 const ton_access_1 = require("@orbs-network/ton-access");
 const ton_1 = require("@ton/ton");
-const artifacts_1 = require("@tonappchain/artifacts");
 const ton_lite_client_1 = require("@tonappchain/ton-lite-client");
+const artifacts_1 = require("../../artifacts");
+const Utils_1 = require("../sdk/Utils");
 const Struct_1 = require("../structs/Struct");
+async function getHttpEndpointWithRetry(network, maxRetries = 5, delay = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const tonNetwork = network === Struct_1.Network.MAINNET ? 'mainnet' : 'testnet';
+            return await (0, ton_access_1.getHttpEndpoint)({ network: tonNetwork });
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt <= maxRetries) {
+                await (0, Utils_1.sleep)(delay);
+            }
+        }
+    }
+    throw lastError || new Error('Failed to get HTTP endpoint after retries');
+}
+async function getHttpV4EndpointWithRetry(network, maxRetries = 5, delay = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const tonNetwork = network === Struct_1.Network.MAINNET ? 'mainnet' : 'testnet';
+            return await (0, ton_access_1.getHttpV4Endpoint)({ network: tonNetwork });
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt <= maxRetries) {
+                await (0, Utils_1.sleep)(delay);
+            }
+        }
+    }
+    throw lastError || new Error('Failed to get HTTP V4 endpoint after retries');
+}
 function intToIP(int) {
     const part1 = int & 255;
     const part2 = (int >> 8) & 255;
@@ -17,7 +50,9 @@ function intToIP(int) {
     return part4 + '.' + part3 + '.' + part2 + '.' + part1;
 }
 async function getDefaultLiteServers(network) {
-    const url = network === Struct_1.Network.TESTNET ? artifacts_1.testnet.DEFAULT_LITESERVERS : artifacts_1.mainnet.DEFAULT_LITESERVERS;
+    const url = network === Struct_1.Network.TESTNET || network === Struct_1.Network.DEV
+        ? artifacts_1.testnet.DEFAULT_LITESERVERS
+        : artifacts_1.mainnet.DEFAULT_LITESERVERS;
     const resp = await fetch(url);
     const liteClients = await resp.json();
     return liteClients.liteservers;
@@ -67,13 +102,11 @@ function sandboxOpener(blockchain) {
     };
 }
 async function orbsOpener(network) {
-    const endpoint = await (0, ton_access_1.getHttpEndpoint)({
-        network,
-    });
+    const endpoint = await getHttpEndpointWithRetry(network);
     return new ton_1.TonClient({ endpoint });
 }
 async function orbsOpener4(network, timeout = 10000) {
-    const endpoint = await (0, ton_access_1.getHttpV4Endpoint)({ network });
+    const endpoint = await getHttpV4EndpointWithRetry(network);
     const client4 = new ton_1.TonClient4({ endpoint, timeout });
     return {
         open: (contract) => client4.open(contract),

package/dist/src/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './contractOpener';
+export * from './retryableContractOpener';

package/dist/src/adapters/index.js

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

package/dist/{adapters → src/adapters}/retryableContractOpener.d.ts

@@ -1,10 +1,13 @@
 import { SandboxContract } from '@ton/sandbox';
 import { Address, Contract, OpenedContract } from '@ton/ton';
-import { mainnet, testnet } from '@tonappchain/artifacts';
-import { ContractOpener, ContractState } from '../structs/Struct';
+import { ContractOpener } from '../interfaces';
+import { ContractState, Network } from '../structs/Struct';
 export interface OpenerConfig {
+    /** Underlying opener implementation to use for this slot. */
     opener: ContractOpener;
+    /** Number of retry attempts before falling back to the next opener. */
     retries: number;
+    /** Delay in milliseconds between retries for this opener. */
     retryDelay: number;
 }
 export declare class RetryableContractOpener implements ContractOpener {
@@ -18,4 +21,4 @@ export declare class RetryableContractOpener implements ContractOpener {
     private createRetryableContract;
     private callMethodAcrossOpeners;
 }
-export declare function createDefaultRetryableOpener(artifacts: typeof testnet | typeof mainnet, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;
+export declare function createDefaultRetryableOpener(tonRpcEndpoint: string, networkType: Network, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;

package/dist/{adapters → src/adapters}/retryableContractOpener.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetryableContractOpener = void 0;
 exports.createDefaultRetryableOpener = createDefaultRetryableOpener;
 const ton_1 = require("@ton/ton");
-const artifacts_1 = require("@tonappchain/artifacts");
 const instances_1 = require("../errors/instances");
 const Struct_1 = require("../structs/Struct");
 const contractOpener_1 = require("./contractOpener");
@@ -86,16 +85,16 @@ class RetryableContractOpener {
     }
 }
 exports.RetryableContractOpener = RetryableContractOpener;
-async function createDefaultRetryableOpener(artifacts, maxRetries = 3, retryDelay = 1000) {
+async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetries = 5, retryDelay = 1000) {
+    const openers = [];
     const tonClient = new ton_1.TonClient({
-        endpoint: new URL('api/v2/jsonRPC', artifacts.TON_RPC_ENDPOINT_BY_TAC).toString(),
+        endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString(),
     });
-    const network = artifacts === artifacts_1.testnet ? Struct_1.Network.TESTNET : Struct_1.Network.MAINNET;
-    const opener4 = await (0, contractOpener_1.orbsOpener4)(network);
-    const opener = await (0, contractOpener_1.orbsOpener)(network);
-    return new RetryableContractOpener([
-        { opener: tonClient, retries: maxRetries, retryDelay },
-        { opener: opener4, retries: maxRetries, retryDelay },
-        { opener: opener, retries: maxRetries, retryDelay },
-    ]);
+    openers.push({ opener: tonClient, retries: maxRetries, retryDelay });
+    if (networkType !== Struct_1.Network.DEV) {
+        const opener4 = await (0, contractOpener_1.orbsOpener4)(networkType);
+        const opener = await (0, contractOpener_1.orbsOpener)(networkType);
+        openers.push({ opener: opener4, retries: maxRetries, retryDelay }, { opener: opener, retries: maxRetries, retryDelay });
+    }
+    return new RetryableContractOpener(openers);
 }

package/dist/src/agnosticSdk/AbiHandler.d.ts

@@ -0,0 +1,27 @@
+import { Interface } from 'ethers';
+export declare class AbiHandler {
+    contractInterfaces: Map<string, Interface>;
+    /**
+     * Add a contract interface for encoding function calls
+     * Supports both human-readable ABI strings and generated ABI JSON objects
+     * @param address - The address of the contract to add interface for
+     * @param abi - The abi of the contract to add interface for
+     * @returns The sdk instance
+     */
+    addContractInterface(address: string, abi: string | any[]): this;
+    /**
+     * Parse ABI - handles both human-readable strings and generated ABI JSON objects
+     * Extracts only function definitions from JSON ABI
+     */
+    private _parseAbi;
+    /**
+     * Build human-readable function signature from JSON ABI function object
+     * @param func - The function to build signature for
+     * @returns The signature of the function
+     */
+    private _buildFunctionSignature;
+    /**
+     * Build parameter type string, handling tuples/structs properly
+     */
+    private _buildParameterType;
+}

package/dist/src/agnosticSdk/AbiHandler.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbiHandler = void 0;
+const ethers_1 = require("ethers");
+class AbiHandler {
+    constructor() {
+        this.contractInterfaces = new Map();
+    }
+    /**
+     * Add a contract interface for encoding function calls
+     * Supports both human-readable ABI strings and generated ABI JSON objects
+     * @param address - The address of the contract to add interface for
+     * @param abi - The abi of the contract to add interface for
+     * @returns The sdk instance
+     */
+    addContractInterface(address, abi) {
+        const parsedAbi = this._parseAbi(abi);
+        this.contractInterfaces.set(address.toLowerCase(), new ethers_1.Interface(parsedAbi));
+        return this;
+    }
+    /**
+     * Parse ABI - handles both human-readable strings and generated ABI JSON objects
+     * Extracts only function definitions from JSON ABI
+     */
+    _parseAbi(abi) {
+        const humanReadableAbi = [];
+        for (const item of abi) {
+            // If it's already a string (human-readable format), keep it
+            if (typeof item === 'string') {
+                humanReadableAbi.push(item);
+                continue;
+            }
+            // If it's a JSON ABI object, parse it
+            if (typeof item === 'object' && item.type) {
+                // Only process functions
+                if (item.type === 'function') {
+                    const signature = this._buildFunctionSignature(item);
+                    if (signature) {
+                        humanReadableAbi.push(signature);
+                    }
+                }
+                // Skip events, errors, constructor, etc.
+            }
+        }
+        return humanReadableAbi;
+    }
+    /**
+     * Build human-readable function signature from JSON ABI function object
+     * @param func - The function to build signature for
+     * @returns The signature of the function
+     */
+    _buildFunctionSignature(func) {
+        if (!func.name || !Array.isArray(func.inputs)) {
+            return null;
+        }
+        // Build parameter list with proper tuple handling
+        const params = func.inputs
+            .map((input) => {
+            const paramType = this._buildParameterType(input);
+            // Add parameter name if available
+            if (input.name) {
+                return `${paramType} ${input.name}`;
+            }
+            return paramType;
+        })
+            .join(', ');
+        // Build return types if available
+        let returnTypes = '';
+        if (func.outputs && func.outputs.length > 0) {
+            const outputs = func.outputs
+                .map((output) => {
+                const outputType = this._buildParameterType(output);
+                if (output.name) {
+                    return `${outputType} ${output.name}`;
+                }
+                return outputType;
+            })
+                .join(', ');
+            returnTypes = ` returns (${outputs})`;
+        }
+        // Build full signature
+        const stateMutability = func.stateMutability || 'nonpayable';
+        let mutabilityKeyword = '';
+        if (stateMutability === 'view') {
+            mutabilityKeyword = ' view';
+        }
+        else if (stateMutability === 'pure') {
+            mutabilityKeyword = ' pure';
+        }
+        else if (stateMutability === 'payable') {
+            mutabilityKeyword = ' payable';
+        }
+        return `function ${func.name}(${params})${mutabilityKeyword} external${returnTypes}`;
+    }
+    /**
+     * Build parameter type string, handling tuples/structs properly
+     */
+    _buildParameterType(param) {
+        if (param.type === 'tuple') {
+            // Handle struct/tuple types
+            if (param.components && Array.isArray(param.components)) {
+                const componentTypes = param.components
+                    .map((component) => {
+                    const baseType = this._buildParameterType(component);
+                    // Include parameter name for struct components if available
+                    if (component.name) {
+                        return `${baseType} ${component.name}`;
+                    }
+                    return baseType;
+                })
+                    .join(',');
+                return `(${componentTypes})`;
+            }
+            return 'tuple'; // fallback
+        }
+        if (param.type === 'tuple[]') {
+            // Handle array of structs
+            if (param.components && Array.isArray(param.components)) {
+                const componentTypes = param.components
+                    .map((component) => {
+                    const baseType = this._buildParameterType(component);
+                    // Include parameter name for struct components if available
+                    if (component.name) {
+                        return `${baseType} ${component.name}`;
+                    }
+                    return baseType;
+                })
+                    .join(',');
+                return `(${componentTypes})[]`;
+            }
+            return 'tuple[]'; // fallback
+        }
+        // Handle regular types and arrays
+        return param.type;
+    }
+}
+exports.AbiHandler = AbiHandler;

package/dist/src/agnosticSdk/AgnosticSdk.d.ts

@@ -0,0 +1,201 @@
+import { Network } from '../structs/Struct';
+import { AmountChange, Hook, NFTData, ZapCall } from './AgnosticStructs';
+/**
+ * SDK for building AgnosticProxy Zap calls with efficient hook encoding
+ * @param network - The network to use (MAINNET || TESTNET || DEV)
+ * @param agnosticProxyAddress - The address of the agnostic proxy(optional)
+ */
+export declare class AgnosticProxySDK {
+    private agnosticProxyAddress;
+    private abiHandler;
+    private replacementHelper;
+    private hooksHandler;
+    private debugHelpers;
+    constructor(network: Network, agnosticProxyAddress?: string);
+    addContractInterface(address: string, abi: string | any[]): this;
+    /**
+     * Create a custom hook with optional dynamic value replacement
+     * @param contractAddress - The address of the contract to call
+     * @param functionName - The name of the function to call
+     * @param params - The parameters of the function to call
+     * @param options - The options of the custom hook
+     * @returns The custom hook
+     */
+    createCustomHook(contractAddress: string, functionName: string, params: any[], options?: {
+        isFromSAPerspective?: boolean;
+        value?: bigint;
+        dynamicReplacements?: AmountChange[];
+    }): Hook;
+    /**
+     * Create a full balance approve hook
+     * @param token - The token to approve
+     * @param to - The address to approve to
+     * @param isFromSAPerspective - Whether the hook is from the smart account perspective or from proxy perspective
+     * @returns The full balance approve hook
+     */
+    createFullBalanceApproveHook(token: string, to: string, isFromSAPerspective?: boolean): Hook;
+    /**
+     * Create a full balance transfer hook
+     * @param token - The token to transfer
+     * @param to - The address to transfer to
+     * @param isFromSAPerspective - Whether the hook is from the smart account perspective or from proxy perspective
+     * @returns The full balance transfer hook
+     */
+    createFullBalanceTransferHook(token: string, to: string, isFromSAPerspective?: boolean): Hook;
+    /**
+     * Utility: Create multiple approve hooks at once
+     * @param approvals - The approvals to create
+     * @returns The multiple approve hooks
+     */
+    createMultipleApproves(approvals: {
+        token: string;
+        spender: string;
+        isFromSA?: boolean;
+    }[]): Hook[];
+    /**
+     * Utility: Create a sequence of custom hooks
+     * @param calls - The calls to create
+     * @returns The hook sequence
+     */
+    createHookSequence(calls: {
+        contract: string;
+        functionName: string;
+        params: any[];
+        options?: {
+            isFromSAPerspective?: boolean;
+            value?: bigint;
+            dynamicReplacements?: AmountChange[];
+        };
+    }[]): Hook[];
+    /**
+     * Helper to create dynamic amount replacement for a specific parameter
+     * @param paramIndex - The index of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @returns The amount replacement
+     */
+    createAmountReplacement(paramIndex: number, token: string, balanceAddress: string): AmountChange;
+    /**
+     * Advanced replacement calculator - calculates position and length for any parameter type
+     * Required that you have added the contract interface first using addContractInterface().
+     * If human readable abi is used, need to provide function and params names also
+     * @param contractAddress - The address of the contract to call
+     * @param functionName - The name of the function to call
+     * @param parameterName - The name of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @returns The replacement data
+     */
+    calculateReplacementData(contractAddress: string, functionName: string, parameterName: string, token: string, balanceAddress: string): AmountChange;
+    /**
+     * Get replacement helper - shows available functions and parameters for a contract
+     * Required that you have added the contract interface first using addContractInterface().
+     * If human readable abi is used, need to provide function and params names also
+     * @param contractAddress - The address of the contract to call
+     * @returns The replacement helper
+     */
+    getReplacementHelper(contractAddress: string): {
+        contractAddress: string;
+        functions: {
+            name: string;
+            signature: string;
+            parameters: {
+                name: string;
+                type: string;
+                index: number;
+                canReplace: boolean;
+                reason?: string;
+            }[];
+        }[];
+    };
+    /**
+     * Interactive replacement builder - helps build replacement step by step
+     * @param contractAddress - The address of the contract to call
+     * @param functionName - The name of the function to call
+     * @param parameterName - The name of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @param options - The options of the interactive replacement builder
+     * @returns The interactive replacement builder
+     */
+    buildReplacementInteractive(contractAddress: string, functionName: string, parameterName: string, token: string, balanceAddress: string, options?: {
+        showCalculation?: boolean;
+        validate?: boolean;
+    }): {
+        replacement: AmountChange;
+        calculation: {
+            functionSignature: string;
+            parameterInfo: {
+                name: string;
+                type: string;
+                index: number;
+                position: number;
+                length: number;
+            };
+            positionCalculation: string;
+        };
+        validation: {
+            isValid: boolean;
+            warnings: string[];
+            suggestions: string[];
+        };
+    };
+    /**
+     * Debug helper: Decode hook data back to readable format
+     * @param hook - The hook to decode
+     * @returns The decoded hook
+     */
+    decodeHookData(hook: Hook): any;
+    /**
+     * Debug helper: Get estimated gas for a ZapCall
+     * @param zapCall - The zap call to estimate the gas usage for
+     * @returns The estimated gas usage
+     */
+    estimateGasUsage(zapCall: ZapCall): number;
+    /**
+     * Visualize ZapCall chain - Human readable description of all operations
+     * @param zapCall - The zap call to visualize
+     */
+    visualizeZapCall(zapCall: ZapCall): void;
+    /**
+     * Get a detailed breakdown of a ZapCall for logging
+     * @param zapCall - The zap call to get the breakdown for
+     * @returns The breakdown of the zap call
+     */
+    getZapCallBreakdown(zapCall: ZapCall): {
+        totalHooks: number;
+        hookTypes: {
+            [key: string]: number;
+        };
+        gasEstimate: number;
+        encodedSize: number;
+        bridgeRequired: boolean;
+        hookDescriptions: string[];
+    };
+    /**
+     * Compare two ZapCalls and show differences
+     * @param zapCall1 - The first zap call to compare
+     * @param zapCall2 - The second zap call to compare
+     * @param label1 - The label of the first zap call
+     * @param label2 - The label of the second zap call
+     */
+    compareZapCalls(zapCall1: ZapCall, zapCall2: ZapCall, label1?: string, label2?: string): void;
+    getAgnosticCallParams(): {
+        evmTargetAddress: string;
+        methodName: string;
+    };
+    /**
+     * Build a complete ZapCall
+     * @param hooks - The hooks of the zap call
+     * @param bridgeTokens - The tokens to bridge
+     * @param bridgeNFTs - The nfts to bridge
+     * @returns The zap call
+     */
+    buildZapCall(hooks: Hook[], bridgeTokens?: string[], bridgeNFTs?: NFTData[]): ZapCall;
+    /**
+     * Encode ZapCall for transaction
+     * @param zapCall - The zap call to encode
+     * @returns The encoded zap call that can be used as calldata in tac sdk
+     */
+    encodeZapCall(zapCall: ZapCall): string;
+}