@tonappchain/sdk 0.7.0-rc17 → 0.7.0-rc19

package/dist/artifacts/mainnet/ton/internal/wrappers/NFTProxy.d.ts

@@ -0,0 +1,84 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+export declare const NFTItemTransferOperation = 2332633442;
+export declare const NFTProxyOpCodes: {
+    admin_changeAdmin: number;
+    admin_updateCode: number;
+    ccl_evmMsgToTVMProxy: number;
+    ccl_errorNotification: number;
+    ccl_tvmMsgToEVM: number;
+    nftItem_ownershipAssigned: number;
+    nftItem_burn: number;
+    nftItem_transfer: number;
+    admin_cancelChangingAdmin: number;
+    newAdmin_confirmChangingAdmin: number;
+};
+export declare const NFTProxyErrors: {
+    notFromCrossChainLayer: number;
+    notFromAdmin: number;
+    notFromNewAdmin: number;
+    newAdminAddressIsNone: number;
+    notEnoughTon: number;
+    invalidPayload: number;
+};
+export type NFTProxyConfig = {
+    cclAddress: Address;
+    adminAddress: Address;
+    newAdminAddress: Address | null;
+};
+export declare function nftProxyConfigToCell(config: NFTProxyConfig): Cell;
+export declare class NFTProxy implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): NFTProxy;
+    static createFromConfig(config: NFTProxyConfig, code: Cell, workchain?: number): NFTProxy;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    static errorNotificationMessage(queryId: number | bigint, operation: number | bigint, itemAddress: Address, owner: Address): Cell;
+    sendErrorNotification(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        operation: number | bigint;
+        itemAddress: Address;
+        owner: Address;
+    }): Promise<void>;
+    static evmMsgToTVMProxyMessage(queryId: number | bigint, itemAddress: Address, newOwner: Address, forwardAmount: bigint): Cell;
+    sendEVMMsgToTVMProxy(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        itemAddress: Address;
+        newOwner: Address;
+        forwardAmount: bigint;
+    }): Promise<void>;
+    static ownershipAssignedMessage(queryId: number | bigint, itemOwner: Address, crosschainTonAmount: bigint, evmData?: Cell, feeData?: Cell): Cell;
+    sendOwnershipAssigned(provider: ContractProvider, via: Sender, value: bigint, params: {
+        queryId?: number | bigint;
+        itemOwner: Address;
+        crosschainTonAmount: bigint;
+        evmData?: Cell;
+        feeData?: Cell;
+    }): Promise<void>;
+    sendUpdateCode(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        code: Cell;
+        data: Cell;
+    }): Promise<void>;
+    sendChangeAdmin(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: number;
+        adminAddress: string;
+    }): Promise<void>;
+    sendCancelChangingAdmin(provider: ContractProvider, via: Sender, value: bigint, opts?: {
+        queryId?: number;
+    }): Promise<void>;
+    sendConfirmNewAdmin(provider: ContractProvider, via: Sender, value: bigint, opts?: {
+        queryId?: number;
+    }): Promise<void>;
+    getFullData(provider: ContractProvider): Promise<{
+        cclAddress: Address;
+        adminAddress: Address;
+        newAdminAddress: Address | null;
+    }>;
+}

package/dist/artifacts/mainnet/ton/internal/wrappers/NFTProxy.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFTProxy = exports.NFTProxyErrors = exports.NFTProxyOpCodes = exports.NFTItemTransferOperation = void 0;
+exports.nftProxyConfigToCell = nftProxyConfigToCell;
+const core_1 = require("@ton/core");
+const Constants_1 = require("./Constants");
+exports.NFTItemTransferOperation = 0x8b092962;
+exports.NFTProxyOpCodes = {
+    admin_changeAdmin: 0x581879bc,
+    admin_updateCode: 0x20faec53,
+    ccl_evmMsgToTVMProxy: 0x7817b330,
+    ccl_errorNotification: 0xae7df95b,
+    ccl_tvmMsgToEVM: 0x6c582059,
+    nftItem_ownershipAssigned: 0x05138d91,
+    nftItem_burn: 0x6656d267,
+    nftItem_transfer: 0x5fcc3d14,
+    admin_cancelChangingAdmin: 0x60094a1b,
+    newAdmin_confirmChangingAdmin: 0x6a4fbe34,
+};
+exports.NFTProxyErrors = {
+    notFromCrossChainLayer: 70,
+    notFromAdmin: 71,
+    notFromNewAdmin: 72,
+    newAdminAddressIsNone: 80,
+    notEnoughTon: 100,
+    invalidPayload: 200,
+};
+function nftProxyConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(config.cclAddress)
+        .storeAddress(config.adminAddress)
+        .storeAddress(config.newAdminAddress)
+        .endCell();
+}
+class NFTProxy {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new NFTProxy(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = nftProxyConfigToCell(config);
+        const init = { code, data };
+        return new NFTProxy((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    static errorNotificationMessage(queryId, operation, itemAddress, owner) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTProxyOpCodes.ccl_errorNotification, Constants_1.Params.bitsize.op)
+            .storeUint(queryId, Constants_1.Params.bitsize.queryId)
+            .storeUint(operation, 32)
+            .storeAddress(itemAddress)
+            .storeAddress(owner)
+            .endCell();
+    }
+    async sendErrorNotification(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTProxy.errorNotificationMessage(params.queryId ?? 0, params.operation, params.itemAddress, params.owner),
+            value,
+        });
+    }
+    static evmMsgToTVMProxyMessage(queryId, itemAddress, newOwner, forwardAmount) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTProxyOpCodes.ccl_evmMsgToTVMProxy, Constants_1.Params.bitsize.op)
+            .storeUint(queryId, Constants_1.Params.bitsize.queryId)
+            .storeAddress(itemAddress)
+            .storeAddress(newOwner)
+            .storeCoins(forwardAmount)
+            .endCell();
+    }
+    async sendEVMMsgToTVMProxy(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTProxy.evmMsgToTVMProxyMessage(params.queryId ?? 0, params.itemAddress, params.newOwner, params.forwardAmount),
+            value,
+        });
+    }
+    static ownershipAssignedMessage(queryId, itemOwner, crosschainTonAmount, evmData, feeData) {
+        return (0, core_1.beginCell)()
+            .storeUint(exports.NFTProxyOpCodes.nftItem_ownershipAssigned, Constants_1.Params.bitsize.op)
+            .storeUint(queryId, Constants_1.Params.bitsize.queryId)
+            .storeAddress(itemOwner)
+            .storeMaybeRef((0, core_1.beginCell)().storeCoins(crosschainTonAmount).storeMaybeRef(feeData).storeMaybeRef(evmData).endCell())
+            .endCell();
+    }
+    async sendOwnershipAssigned(provider, via, value, params) {
+        await provider.internal(via, {
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: NFTProxy.ownershipAssignedMessage(params.queryId ?? 0, params.itemOwner, params.crosschainTonAmount, params.evmData, params.feeData),
+            value,
+        });
+    }
+    async sendUpdateCode(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTProxyOpCodes.admin_updateCode, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeRef(opts.code)
+                .storeRef(opts.data)
+                .endCell(),
+        });
+    }
+    async sendChangeAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTProxyOpCodes.admin_changeAdmin, Constants_1.Params.bitsize.op)
+                .storeUint(opts.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .storeAddress(!!opts.adminAddress ? core_1.Address.parse(opts.adminAddress) : null)
+                .endCell(),
+        });
+    }
+    async sendCancelChangingAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTProxyOpCodes.admin_cancelChangingAdmin, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async sendConfirmNewAdmin(provider, via, value, opts) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.NFTProxyOpCodes.newAdmin_confirmChangingAdmin, Constants_1.Params.bitsize.op)
+                .storeUint(opts?.queryId || 0, Constants_1.Params.bitsize.queryId)
+                .endCell(),
+        });
+    }
+    async getFullData(provider) {
+        const res = await provider.get('get_full_data', []);
+        const cclAddress = res.stack.readAddress();
+        const adminAddress = res.stack.readAddress();
+        const newAdminAddress = res.stack.readAddressOpt();
+        return {
+            cclAddress,
+            adminAddress,
+            newAdminAddress,
+        };
+    }
+}
+exports.NFTProxy = NFTProxy;

package/dist/artifacts/mainnet/ton/internal/wrappers/Settings.d.ts

@@ -0,0 +1,80 @@
+import { Address, Cell, Contract, ContractProvider, Dictionary, Sender } from '@ton/core';
+import { StorageStats } from './utils/GasUtils';
+export type SettingsConfig = {
+    settingsId?: number;
+    settings: Dictionary<bigint, Cell>;
+    adminAddress: Address;
+    newAdminAddress?: Address;
+};
+export type SendValueParams = {
+    queryId?: number;
+    key: bigint;
+    value: Cell;
+};
+export type ChangeAdminParams = {
+    queryId?: number;
+    adminAddress: Address;
+};
+export type GetValueParams = {
+    queryId?: number;
+    key: bigint;
+};
+export type SettingsValue = {
+    found: boolean;
+    value: Cell | null;
+};
+export type AdminAddresses = {
+    adminAddress: Address;
+    newAdminAddress: Address | undefined;
+};
+export declare const SettingsOpCodes: {
+    admin_setValue: number;
+    admin_changeAdmin: number;
+    admin_cancelChangingAdmin: number;
+    newAdmin_confirmChangingAdmin: number;
+    anyone_getValue: number;
+    anyone_getAll: number;
+    settings_sendValue: number;
+    settings_sendAll: number;
+};
+export declare const SettingsErrors: {
+    noErrors: number;
+    notFromAdmin: number;
+    notFromNewAdmin: number;
+    newAdminAddressIsNone: number;
+    notEnoughTon: number;
+};
+export declare function settingsConfigToCell(config: SettingsConfig): Cell;
+export declare class Settings implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    readonly configuration?: SettingsConfig | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined, configuration?: SettingsConfig | undefined);
+    static minStorageDuration: number;
+    static minStorageStats: StorageStats;
+    static createFromAddress(address: Address): Settings;
+    static createFromConfig(config: SettingsConfig, code: Cell, workchain?: number): Settings;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendSetValue(provider: ContractProvider, via: Sender, value: bigint, params: SendValueParams): Promise<void>;
+    sendGetValue(provider: ContractProvider, via: Sender, value: bigint, params: GetValueParams): Promise<void>;
+    sendGetAll(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        queryId?: number;
+    }): Promise<void>;
+    sendChangeAdmin(provider: ContractProvider, via: Sender, value: bigint, params?: ChangeAdminParams): Promise<void>;
+    sendCancelChangingAdmin(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        queryId?: number;
+    }): Promise<void>;
+    sendConfirmChangingAdmin(provider: ContractProvider, via: Sender, value: bigint, params?: {
+        queryId?: number;
+    }): Promise<void>;
+    getValue(provider: ContractProvider, key: bigint): Promise<SettingsValue>;
+    getAdminAddresses(provider: ContractProvider): Promise<AdminAddresses>;
+    getAll(provider: ContractProvider): Promise<Cell>;
+    getFullData(provider: ContractProvider): Promise<SettingsConfig>;
+}

package/dist/artifacts/mainnet/ton/internal/wrappers/Settings.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Settings = exports.SettingsErrors = exports.SettingsOpCodes = void 0;
+exports.settingsConfigToCell = settingsConfigToCell;
+const core_1 = require("@ton/core");
+const GasUtils_1 = require("./utils/GasUtils");
+exports.SettingsOpCodes = {
+    admin_setValue: 0x245e9406,
+    admin_changeAdmin: 0x581879bc,
+    admin_cancelChangingAdmin: 0x60094a1b,
+    newAdmin_confirmChangingAdmin: 0x6a4fbe34,
+    anyone_getValue: 0x399685b8,
+    anyone_getAll: 0x40148d4a,
+    settings_sendValue: 0x707a28d2,
+    settings_sendAll: 0xcf03b318,
+};
+exports.SettingsErrors = {
+    noErrors: 0,
+    notFromAdmin: 70,
+    notFromNewAdmin: 71,
+    newAdminAddressIsNone: 80,
+    notEnoughTon: 100,
+};
+function settingsConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeUint(config.settingsId ?? 0, 8)
+        .storeAddress(config.adminAddress)
+        .storeAddress(config.newAdminAddress ?? null)
+        .storeDict(config.settings)
+        .endCell();
+}
+class Settings {
+    constructor(address, init, configuration) {
+        this.address = address;
+        this.init = init;
+        this.configuration = configuration;
+    }
+    static createFromAddress(address) {
+        return new Settings(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = settingsConfigToCell(config);
+        const init = { code, data };
+        return new Settings((0, core_1.contractAddress)(workchain, init), init, config);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    async sendSetValue(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.SettingsOpCodes.admin_setValue, 32)
+                .storeUint(params.queryId ?? 0, 64)
+                .storeUint(params.key, 256)
+                .storeRef(params.value)
+                .endCell(),
+        });
+    }
+    async sendGetValue(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.SettingsOpCodes.anyone_getValue, 32)
+                .storeUint(params.queryId ?? 0, 64)
+                .storeUint(params.key, 256)
+                .endCell(),
+        });
+    }
+    async sendGetAll(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.SettingsOpCodes.anyone_getAll, 32)
+                .storeUint(params?.queryId ?? 0, 64)
+                .endCell(),
+        });
+    }
+    async sendChangeAdmin(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.SettingsOpCodes.admin_changeAdmin, 32)
+                .storeUint(params?.queryId ?? 0, 64)
+                .storeAddress(params?.adminAddress ?? null)
+                .endCell(),
+        });
+    }
+    async sendCancelChangingAdmin(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.SettingsOpCodes.admin_cancelChangingAdmin, 32)
+                .storeUint(params?.queryId ?? 0, 64)
+                .endCell(),
+        });
+    }
+    async sendConfirmChangingAdmin(provider, via, value, params) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(exports.SettingsOpCodes.newAdmin_confirmChangingAdmin, 32)
+                .storeUint(params?.queryId ?? 0, 64)
+                .endCell(),
+        });
+    }
+    async getValue(provider, key) {
+        const { stack } = await provider.get('get', [{ type: 'int', value: key }]);
+        return {
+            value: stack.readCellOpt(),
+            found: stack.readBoolean(),
+        };
+    }
+    async getAdminAddresses(provider) {
+        const { stack } = await provider.get('get_admin_addresses', []);
+        return {
+            adminAddress: stack.readAddress(),
+            newAdminAddress: stack.readAddressOpt() ?? undefined,
+        };
+    }
+    async getAll(provider) {
+        const { stack } = await provider.get('get_all', []);
+        return stack.readCellOpt() ?? (0, core_1.beginCell)().endCell();
+    }
+    async getFullData(provider) {
+        const { stack } = await provider.get('get_full_data', []);
+        const settingsId = stack.readNumber();
+        const adminAddress = stack.readAddress();
+        const newAdminAddress = stack.readAddressOpt() ?? undefined;
+        const settings = stack.readCellOpt();
+        return {
+            settingsId,
+            adminAddress,
+            newAdminAddress,
+            settings: settings?.beginParse().loadDictDirect(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Cell()) ??
+                core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Cell()),
+        };
+    }
+}
+exports.Settings = Settings;
+Settings.minStorageDuration = 10 * 365 * 24 * 3600; // 10 years
+Settings.minStorageStats = new GasUtils_1.StorageStats(29557n, 104n);

package/dist/artifacts/mainnet/ton/internal/wrappers/utils/GasUtils.d.ts

@@ -0,0 +1,79 @@
+import { Cell, Slice, Message, DictionaryValue, Transaction } from '@ton/core';
+export type GasPrices = {
+    flat_gas_limit: bigint;
+    flat_gas_price: bigint;
+    gas_price: bigint;
+};
+export type StorageValue = {
+    utime_sice: number;
+    bit_price_ps: bigint;
+    cell_price_ps: bigint;
+    mc_bit_price_ps: bigint;
+    mc_cell_price_ps: bigint;
+};
+export type MsgPrices = ReturnType<typeof configParseMsgPrices>;
+export type FullFees = ReturnType<typeof computeFwdFeesVerbose>;
+export declare class StorageStats {
+    bits: bigint;
+    cells: bigint;
+    constructor(bits?: number | bigint, cells?: number | bigint);
+    add(...stats: StorageStats[]): StorageStats;
+    sub(...stats: StorageStats[]): StorageStats;
+    addBits(bits: number | bigint): StorageStats;
+    subBits(bits: number | bigint): StorageStats;
+    addCells(cells: number | bigint): StorageStats;
+    subCells(cells: number | bigint): StorageStats;
+    toString(): string;
+}
+export declare function computedGeneric<T extends Transaction>(transaction: T): import("@ton/core").TransactionComputeVm;
+export declare function storageGeneric<T extends Transaction>(transaction: T): import("@ton/core").TransactionStoragePhase;
+export declare function shr16ceil(src: bigint): bigint;
+export declare function collectCellStats(cell: Cell, visited: Array<string>, skipRoot?: boolean): StorageStats;
+export declare function getGasPrices(configRaw: Cell, workchain: 0 | -1): GasPrices;
+export declare function setGasPrice(configRaw: Cell, prices: GasPrices, workchain: 0 | -1): Cell;
+export declare const storageValue: DictionaryValue<StorageValue>;
+export declare function getStoragePrices(configRaw: Cell): StorageValue;
+export declare function calcStorageFee(prices: StorageValue, stats: StorageStats, duration: bigint): bigint;
+export declare function calcMasterchainStorageFee(prices: StorageValue, stats: StorageStats, duration: bigint): bigint;
+export declare function setStoragePrices(configRaw: Cell, prices: StorageValue): Cell;
+export declare function computeGasFee(prices: GasPrices, gas: bigint): bigint;
+export declare function computeDefaultForwardFee(msgPrices: MsgPrices): bigint;
+export declare function computeCellForwardFees(msgPrices: MsgPrices, msg: Cell): bigint;
+export declare function computeMessageForwardFees(msgPrices: MsgPrices, msg: Message): {
+    fees: bigint;
+    res: bigint;
+    remaining: bigint;
+    stats: StorageStats;
+} | {
+    fees: {
+        total: bigint;
+        res: bigint;
+        remaining: bigint;
+    };
+    stats: StorageStats;
+    res?: undefined;
+    remaining?: undefined;
+};
+export declare const configParseMsgPrices: (sc: Slice) => {
+    lumpPrice: bigint;
+    bitPrice: bigint;
+    cellPrice: bigint;
+    ihrPriceFactor: bigint;
+    firstFrac: bigint;
+    nextFrac: bigint;
+};
+export declare const setMsgPrices: (configRaw: Cell, prices: MsgPrices, workchain: 0 | -1) => Cell;
+export declare const getMsgPrices: (configRaw: Cell, workchain: 0 | -1) => {
+    lumpPrice: bigint;
+    bitPrice: bigint;
+    cellPrice: bigint;
+    ihrPriceFactor: bigint;
+    firstFrac: bigint;
+    nextFrac: bigint;
+};
+export declare function computeFwdFees(msgPrices: MsgPrices, cells: bigint, bits: bigint): bigint;
+export declare function computeFwdFeesVerbose(msgPrices: MsgPrices, cells: bigint | number, bits: bigint | number): {
+    total: bigint;
+    res: bigint;
+    remaining: bigint;
+};