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

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

@@ -1,14 +1,17 @@
 import { SandboxContract } from '@ton/sandbox';
-import { OpenedContract } from '@ton/ton';
+import type { Address, Cell, Contract, OpenedContract } from '@ton/ton';
 import { AbstractProvider, Addressable } from 'ethers';
-import { JettonMinter, JettonMinterData } from '../../artifacts/tonTypes';
-import type { FT, NFT } from '../assets';
-import type { Asset, ContractOpener, ILogger } from '../interfaces';
+import { ILogger } from './Services';
 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",
@@ -17,17 +20,12 @@ export declare enum SimplifiedStatuses {
 }
 export declare enum Network {
     TESTNET = "testnet",
-    MAINNET = "mainnet",
-    DEV = "dev"
+    MAINNET = "mainnet"
 }
 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",
@@ -111,25 +109,22 @@ export type TransactionLinker = {
 export type TransactionLinkerWithOperationId = TransactionLinker & {
     operationId?: 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;
+export type TACSimulationRequest = {
+    tacCallParams: {
+        arguments: string;
+        methodName: string;
+        target: string;
+    };
+    evmValidExecutors: string[];
+    tvmValidExecutors: string[];
+    extraData: string;
     shardsKey: string;
-    tonAssets: TONAsset[];
+    tonAssets: {
+        amount: string;
+        tokenAddress: string;
+        assetType: string;
+    }[];
     tonCaller: string;
-    calculateRollbackFee?: boolean;
 };
 export declare enum StageName {
     COLLECTED_IN_TAC = "collectedInTAC",
@@ -209,8 +204,8 @@ export type MetaInfo = {
     initialCaller: InitialCallerInfo;
     validExecutors: ValidExecutors;
     feeInfo: FeeInfo;
-    sentAssets: AssetMovementInfo | null;
-    receivedAssets: AssetMovementInfo | null;
+    sentAssets: AssetMovementInfo;
+    receivedAssets: AssetMovementInfo;
 };
 export type ExecutionStages = {
     operationType: OperationType;
@@ -265,7 +260,7 @@ export type TACSimulationResult = {
         blockNumber: number;
     };
 };
-export type SuggestedTVMExecutorFee = {
+export type SuggestedTONExecutorFee = {
     inTAC: string;
     inTON: string;
 };
@@ -284,9 +279,6 @@ export type CrossChainTransactionOptions = {
     evmExecutorFee?: bigint;
     tvmValidExecutors?: string[];
     tvmExecutorFee?: bigint;
-    calculateRollbackFee?: boolean;
-    withoutSimulation?: boolean;
-    validateAssetsBalance?: boolean;
 };
 export type ExecutionFeeEstimationResult = {
     feeParams: FeeParams;
@@ -297,26 +289,14 @@ export type CrosschainTx = {
     assets?: Asset[];
     options?: CrossChainTransactionOptions;
 };
-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 type NFTItemData = {
+    init: boolean;
+    index: number;
+    collectionAddress: Address;
+    ownerAddress: Address | null;
+    content: Cell | null;
 };
-export interface WaitOptions<T = unknown, TContext = unknown> {
+export interface WaitOptions<T = unknown> {
     /**
      * Timeout in milliseconds
      * @default 300000 (5 minutes)
@@ -336,23 +316,40 @@ export interface WaitOptions<T = unknown, TContext = 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, 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;
+    successCheck?: (result: T) => boolean;
 }
 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"
@@ -374,31 +371,3 @@ 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/{src/structs → 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.Origin = exports.defaultWaitOptions = exports.TokenSymbol = exports.StageName = exports.NFTAddressType = exports.AssetType = exports.OperationType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
 var SimplifiedStatuses;
 (function (SimplifiedStatuses) {
     SimplifiedStatuses["PENDING"] = "PENDING";
@@ -12,18 +12,12 @@ 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/{src/wrappers → wrappers}/HighloadWalletV3.d.ts

@@ -1,5 +1,5 @@
 import { Address, Cell, ContractProvider, MessageRelaxed, OutAction, OutActionSendMsg, SendMode } from '@ton/ton';
-import { WalletInstanse } from '../interfaces';
+import { WalletInstance } from '../sender';
 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 WalletInstanse {
+export declare class HighloadWalletV3 implements WalletInstance {
     readonly address: Address;
     readonly init?: {
         code: Cell;

package/dist/wrappers/JettonMaster.d.ts

@@ -0,0 +1,24 @@
+import { Address, Cell, Contract, ContractProvider } from '@ton/ton';
+import type { JettonExtendedMetadata } from './ContentUtils';
+export type JettonMasterInitData = {
+    evmTokenAddress: string;
+    crossChainLayerAddress: Address;
+    code: Cell;
+    walletCode: Cell;
+};
+export type JettonMasterData = {
+    totalSupply: number;
+    mintable: boolean;
+    adminAddress: string;
+    content: JettonExtendedMetadata;
+    jettonWalletCode: Cell;
+};
+export declare class JettonMaster implements Contract {
+    static createFromAddress(address: Address): JettonMaster;
+    static createFromConfig(config: JettonMasterInitData, workchain?: number): JettonMaster;
+    readonly address: Address;
+    constructor(address: Address);
+    getWalletAddress(provider: ContractProvider, owner: string): Promise<string>;
+    getJettonData(provider: ContractProvider): Promise<JettonMasterData>;
+    getEVMAddress(provider: ContractProvider): Promise<string>;
+}

package/dist/wrappers/JettonMaster.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonMaster = void 0;
+const ton_1 = require("@ton/ton");
+const ContentUtils_1 = require("./ContentUtils");
+class JettonMaster {
+    static createFromAddress(address) {
+        return new JettonMaster(address);
+    }
+    static createFromConfig(config, workchain = 0) {
+        const data = (0, ton_1.beginCell)()
+            .storeCoins(0)
+            .storeAddress(config.crossChainLayerAddress)
+            .storeAddress(null)
+            .storeRef((0, ton_1.beginCell)().endCell())
+            .storeRef(config.walletCode)
+            .storeStringTail(config.evmTokenAddress)
+            .endCell();
+        return JettonMaster.createFromAddress((0, ton_1.contractAddress)(workchain, { data, code: config.code }));
+    }
+    constructor(address) {
+        this.address = address;
+    }
+    async getWalletAddress(provider, owner) {
+        const res = await provider.get('get_wallet_address', [
+            {
+                type: 'slice',
+                cell: (0, ton_1.beginCell)().storeAddress(ton_1.Address.parse(owner)).endCell(),
+            },
+        ]);
+        return res.stack.readAddress().toString();
+    }
+    async getJettonData(provider) {
+        const result = await provider.get('get_jetton_data', []);
+        const totalSupply = Number((0, ton_1.fromNano)(result.stack.readBigNumber()));
+        const mintable = result.stack.readBoolean();
+        const adminAddress = result.stack.readAddress().toString();
+        const content = await (0, ContentUtils_1.readJettonMetadata)(result.stack.readCell());
+        const jettonWalletCode = result.stack.readCell();
+        return {
+            totalSupply,
+            mintable,
+            adminAddress,
+            content,
+            jettonWalletCode,
+        };
+    }
+    async getEVMAddress(provider) {
+        const result = await provider.get('get_evm_token_address', []);
+        return result.stack.readString();
+    }
+}
+exports.JettonMaster = JettonMaster;

package/dist/{artifacts/mainnet/ton/internal/wrappers → wrappers}/JettonWallet.d.ts

@@ -1,10 +1,5 @@
-import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
-import { StorageStats } from './utils/GasUtils';
-export type JettonWalletConfig = {
-    balance: bigint;
-    ownerAddress: string;
-    jettonMasterAddress: string;
-};
+import { Contract, ContractProvider, Sender } from '@ton/ton';
+import { Address, Cell } from '@ton/ton';
 export type JettonWalletData = {
     balance: bigint;
     ownerAddress: string;
@@ -12,71 +7,40 @@ export type JettonWalletData = {
     jettonWalletCode: Cell;
 };
 export declare enum JettonWalletOpCodes {
-    Burn = 1499400124,
-    InternalTransfer = 395134233,
-    Transfer = 260734629,
-    TransferNotification = 1935855772,
-    Excesses = 3576854235,
-    ReturnTon = 89105253,
-    BurnNotification = 2078119902
+    burn = 1499400124,
+    transfer = 260734629,
+    internalTransfer = 395134233
 }
-export declare const JettonWalletErrors: {
-    noErrors: number;
-    notEnoughGas: number;
-    notBounceableOp: number;
-    notWorkchain: number;
-    notMasterchain: number;
-    notFromJettonMaster: number;
-    notFromOwner: number;
-    insufficientJettonBalance: number;
-    notFromJettonMasterOrWallet: number;
-    emptyForwardPayload: number;
-    insufficientMsgValue: number;
-    invalidReceiverAddress: number;
-    unknownOp: number;
-};
-export declare function jettonWalletConfigToCell(config: JettonWalletConfig): Cell;
+export declare function jettonWalletConfigToCell(config: JettonWalletData): Cell;
 export declare class JettonWallet implements Contract {
     readonly address: Address;
     readonly init?: {
         code: Cell;
         data: Cell;
     } | undefined;
-    static storageStats: StorageStats;
-    static stateInitStats: StorageStats;
     constructor(address: Address, init?: {
         code: Cell;
         data: Cell;
     } | undefined);
     static createFromAddress(address: Address): JettonWallet;
-    static createFromConfig(config: JettonWalletConfig, code: Cell, workchain?: number): JettonWallet;
-    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static createFromConfig(config: JettonWalletData, code: Cell, workchain?: number): JettonWallet;
+    static burnMessage(jettonAmount: bigint, receiverAddress?: string, crossChainTonAmount?: bigint, feeData?: Cell | null, crossChainPayload?: Cell | null, queryId?: number): Cell;
     sendBurn(provider: ContractProvider, via: Sender, value: bigint, opts: {
         queryId?: number;
-        jettonAmount: number;
+        jettonAmount: bigint;
         receiverAddress?: string;
-        crossChainTonAmount?: number;
-        feeData?: Cell | null;
-        crossChainPayload?: Cell | null;
-    }): Promise<void>;
-    sendCrossChainTransfer(provider: ContractProvider, via: Sender, value: bigint, opts: {
-        queryId?: number;
-        jettonAmount: number;
-        toOwnerAddress: string;
-        responseAddress?: string;
-        customPayload?: Cell | null;
-        forwardTonAmount?: number;
-        crossChainTonAmount?: number;
+        crossChainTonAmount?: bigint;
         feeData?: Cell | null;
         crossChainPayload?: Cell | null;
     }): Promise<void>;
+    static transferMessage(jettonAmount: bigint, to: string, responseAddress: string | null, forwardTonAmount?: bigint, crossChainTonAmount?: bigint, feeData?: Cell | null, crossChainPayload?: Cell | null, queryId?: number): Cell;
     sendTransfer(provider: ContractProvider, via: Sender, value: bigint, opts: {
         queryId?: number;
-        jettonAmount: number;
+        jettonAmount: bigint;
         toOwnerAddress: string;
         responseAddress?: string;
         customPayload?: Cell | null;
-        forwardTonAmount?: number;
+        forwardTonAmount?: bigint;
         forwardPayload?: Cell | null;
     }): Promise<void>;
     sendReceive(provider: ContractProvider, via: Sender, value: bigint, opts: {
@@ -87,9 +51,6 @@ export declare class JettonWallet implements Contract {
         forwardTonAmount?: number;
         forwardPayload?: Cell;
     }): Promise<void>;
-    sendReturnTon(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
-    static transferMessage(jettonAmount: bigint, to: string, responseAddress: string | null, forwardTonAmount?: bigint, crossChainTonAmount?: bigint, feeData?: Cell | null, crossChainPayload?: Cell | null, queryId?: number): Cell;
-    static burnMessage(jettonAmount: bigint, receiverAddress?: string, crossChainTonAmount?: bigint, feeData?: Cell | null, crossChainPayload?: Cell | null, queryId?: number): Cell;
     getWalletData(provider: ContractProvider): Promise<JettonWalletData>;
     getJettonBalance(provider: ContractProvider): Promise<bigint>;
 }

package/dist/wrappers/JettonWallet.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonWallet = exports.JettonWalletOpCodes = void 0;
+exports.jettonWalletConfigToCell = jettonWalletConfigToCell;
+const ton_1 = require("@ton/ton");
+const ton_2 = require("@ton/ton");
+var JettonWalletOpCodes;
+(function (JettonWalletOpCodes) {
+    JettonWalletOpCodes[JettonWalletOpCodes["burn"] = 1499400124] = "burn";
+    JettonWalletOpCodes[JettonWalletOpCodes["transfer"] = 260734629] = "transfer";
+    JettonWalletOpCodes[JettonWalletOpCodes["internalTransfer"] = 395134233] = "internalTransfer";
+})(JettonWalletOpCodes || (exports.JettonWalletOpCodes = JettonWalletOpCodes = {}));
+function jettonWalletConfigToCell(config) {
+    return (0, ton_2.beginCell)()
+        .storeCoins(config.balance)
+        .storeAddress(ton_2.Address.parse(config.ownerAddress))
+        .storeAddress(ton_2.Address.parse(config.jettonMasterAddress))
+        .endCell();
+}
+class JettonWallet {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new JettonWallet(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jettonWalletConfigToCell(config);
+        const init = { code, data };
+        return new JettonWallet((0, ton_2.contractAddress)(workchain, init), init);
+    }
+    static burnMessage(jettonAmount, receiverAddress, crossChainTonAmount, feeData, crossChainPayload, queryId) {
+        const body = (0, ton_2.beginCell)()
+            .storeUint(JettonWalletOpCodes.burn, 32)
+            .storeUint(queryId || 0, 64)
+            .storeCoins(jettonAmount)
+            .storeAddress(receiverAddress ? ton_2.Address.parse(receiverAddress) : null);
+        if (crossChainTonAmount || crossChainPayload) {
+            body.storeMaybeRef((0, ton_2.beginCell)()
+                .storeCoins(crossChainTonAmount ?? 0n)
+                .storeMaybeRef(feeData)
+                .storeMaybeRef(crossChainPayload)
+                .endCell());
+        }
+        else {
+            body.storeMaybeRef(null);
+        }
+        return body.endCell();
+    }
+    async sendBurn(provider, via, value, opts) {
+        const body = JettonWallet.burnMessage(opts.jettonAmount, opts.receiverAddress, opts.crossChainTonAmount, opts.feeData, opts.crossChainPayload, opts.queryId);
+        await provider.internal(via, {
+            value,
+            sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
+            body: body,
+        });
+    }
+    static transferMessage(jettonAmount, to, responseAddress, forwardTonAmount, crossChainTonAmount, feeData, crossChainPayload, queryId) {
+        return (0, ton_2.beginCell)()
+            .storeUint(JettonWalletOpCodes.transfer, 32)
+            .storeUint(queryId ?? 0, 64)
+            .storeCoins(jettonAmount)
+            .storeAddress(ton_2.Address.parse(to))
+            .storeAddress(responseAddress ? ton_2.Address.parse(responseAddress) : null)
+            .storeMaybeRef(null)
+            .storeCoins(forwardTonAmount || 0n)
+            .storeMaybeRef((0, ton_2.beginCell)()
+            .storeCoins(crossChainTonAmount ?? 0n)
+            .storeMaybeRef(feeData)
+            .storeMaybeRef(crossChainPayload)
+            .endCell())
+            .endCell();
+    }
+    async sendTransfer(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_2.beginCell)()
+                .storeUint(JettonWalletOpCodes.transfer, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeCoins(opts.jettonAmount)
+                .storeAddress(ton_2.Address.parse(opts.toOwnerAddress))
+                .storeAddress(opts.responseAddress ? ton_2.Address.parse(opts.responseAddress) : null)
+                .storeMaybeRef(opts.customPayload)
+                .storeCoins(opts.forwardTonAmount ?? 0n)
+                .storeMaybeRef(opts.forwardPayload)
+                .endCell(),
+        });
+    }
+    async sendReceive(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_2.beginCell)()
+                .storeUint(JettonWalletOpCodes.internalTransfer, 32)
+                .storeUint(opts.queryId || 0, 64)
+                .storeCoins((0, ton_1.toNano)(opts.jettonAmount.toFixed(9)))
+                .storeAddress(opts.fromOwnerAddress ? ton_2.Address.parse(opts.fromOwnerAddress) : null)
+                .storeAddress(opts.responseAddress ? ton_2.Address.parse(opts.responseAddress) : null)
+                .storeCoins(opts.forwardTonAmount || 0)
+                .storeMaybeRef(opts.forwardPayload)
+                .endCell(),
+        });
+    }
+    async getWalletData(provider) {
+        const result = await provider.get('get_wallet_data', []);
+        return {
+            balance: result.stack.readBigNumber(),
+            ownerAddress: result.stack.readAddress().toString(),
+            jettonMasterAddress: result.stack.readAddress().toString(),
+            jettonWalletCode: result.stack.readCell(),
+        };
+    }
+    async getJettonBalance(provider) {
+        const state = await provider.getState();
+        if (state.state.type !== 'active') {
+            return 0n;
+        }
+        const result = await provider.get('get_wallet_data', []);
+        return result.stack.readBigNumber();
+    }
+}
+exports.JettonWallet = JettonWallet;

package/dist/wrappers/Settings.d.ts

@@ -0,0 +1,10 @@
+import type { Cell, Contract, ContractProvider } from '@ton/ton';
+import { Address } from '@ton/ton';
+export declare class Settings implements Contract {
+    static create(address: Address): Settings;
+    readonly address: Address;
+    constructor(address: Address);
+    getKeyFromString(ContractName: string): bigint;
+    getAddressSetting(provider: ContractProvider, ContractName: string): Promise<string>;
+    getCellSetting(provider: ContractProvider, setting: string): Promise<Cell>;
+}

package/dist/wrappers/Settings.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Settings = void 0;
+const ethers_1 = require("ethers");
+const errors_1 = require("../errors");
+class Settings {
+    static create(address) {
+        return new Settings(address);
+    }
+    constructor(address) {
+        this.address = address;
+    }
+    getKeyFromString(ContractName) {
+        const hash = ethers_1.ethers.sha256(ethers_1.ethers.toUtf8Bytes(ContractName));
+        return ethers_1.ethers.toBigInt(hash);
+    }
+    async getAddressSetting(provider, ContractName) {
+        const key = this.getKeyFromString(ContractName);
+        const { stack } = await provider.get('get', [{ type: 'int', value: key }]);
+        const cell = stack.readCellOpt();
+        const found = stack.readBoolean();
+        if (!found) {
+            return '';
+        }
+        return cell ? cell.beginParse().loadAddress().toString() : '';
+    }
+    async getCellSetting(provider, setting) {
+        const key = this.getKeyFromString(setting);
+        const { stack } = await provider.get('get', [{ type: 'int', value: key }]);
+        const cell = stack.readCellOpt();
+        const found = stack.readBoolean();
+        if (!found || cell == null) {
+            throw (0, errors_1.emptySettingError)(setting);
+        }
+        return cell;
+    }
+}
+exports.Settings = Settings;

package/package.json

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

package/dist/artifacts/dev/index.d.ts

@@ -1,9 +0,0 @@
-import { DEV_AGNOSTIC_PROXY_ADDRESS as AGNOSTIC_PROXY_ADDRESS, DEV_MULTICALL_3_ADDRESS as MULTICALL_3_ADDRESS, DEV_TAC_SETTINGS_ADDRESS as TAC_SETTINGS_ADDRESS, DEV_TAC_SMART_ACCOUNT_FACTORY_ADDRESS as TAC_SMART_ACCOUNT_FACTORY_ADDRESS } from './tac/addresses';
-import { DEV_PUBLIC_LITE_SEQUENCER_ENDPOINTS as PUBLIC_LITE_SEQUENCER_ENDPOINTS, DEV_TAC_RPC_ENDPOINT as TAC_RPC_ENDPOINT } from "./tac/endpoints";
-import { DEV_TON_SETTINGS_ADDRESS as TON_SETTINGS_ADDRESS } from './ton/addresses';
-import { DEV_DEFAULT_LITESERVERS as DEFAULT_LITESERVERS, DEV_TON_PUBLIC_RPC_ENDPOINT as TON_PUBLIC_RPC_ENDPOINT, DEV_TON_RPC_ENDPOINT_BY_TAC as TON_RPC_ENDPOINT_BY_TAC } from "./ton/endpoints";
-export * as tac from "./tac";
-export { PUBLIC_LITE_SEQUENCER_ENDPOINTS, TAC_RPC_ENDPOINT };
-export * as ton from "./ton";
-export { DEFAULT_LITESERVERS, TON_PUBLIC_RPC_ENDPOINT, TON_RPC_ENDPOINT_BY_TAC };
-export { AGNOSTIC_PROXY_ADDRESS, MULTICALL_3_ADDRESS, TAC_SETTINGS_ADDRESS, TAC_SMART_ACCOUNT_FACTORY_ADDRESS, TON_SETTINGS_ADDRESS };