wan-ton-sdk 0.0.7 → 0.0.9

package/dist/Bridge.compile.d.ts

@@ -0,0 +1,2 @@
+import { CompilerConfig } from '@ton/blueprint';
+export declare const compile: CompilerConfig;

package/dist/Bridge.compile.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+exports.compile = {
+    lang: 'func',
+    targets: [
+        'contracts/bridge.fc'
+    ],
+};

package/dist/Bridge.d.ts

@@ -0,0 +1,208 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+import { Blockchain } from "@ton/sandbox";
+import { WanTonClient } from "./client/client-interface";
+export type BridgeConfig = {
+    owner: Address;
+    halt: number;
+    init: number;
+    smgFeeProxy: Address;
+    oracleAdmin: Address;
+    operator: Address;
+};
+export type CrossConfig = {
+    owner: Address;
+    admin: Address;
+    halt: number;
+    init: number;
+};
+export declare function bridgeConfigToCell(config: BridgeConfig): Cell;
+export declare class Bridge implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    };
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    });
+    static createFromAddress(address: Address): Bridge;
+    static createFromConfig(config: BridgeConfig, code: Cell, workchain?: number): Bridge;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendSetTokenPairFee(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        tokenPairID: number;
+        fee: number;
+    }): Promise<void>;
+    sendSetTokenPairFees(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        tokenPairID: number[];
+        fee: number[];
+    }): Promise<void>;
+    sendSetChainFee(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        srcChainId: number;
+        dstChainId: number;
+        contractFee: number;
+        agentFee: number;
+    }): Promise<void>;
+    sendSetChainFees(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        srcChainId: number[];
+        dstChainId: number[];
+        contractFee: number[];
+        agentFee: number[];
+    }): Promise<void>;
+    sendAddTokenPair(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        tokenPairId: number;
+        fromChainID: number;
+        fromAccount: string;
+        toChainID: number;
+        toAccount: string;
+        jettonAdminAddr: string;
+        walletCodeBase64?: string;
+    }): Promise<void>;
+    sendRemoveTokenPair(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        tokenPairId: number;
+    }): Promise<void>;
+    getJettonWalletAddr(provider: ContractProvider, jettonMaster: Address, owner: Address): Promise<Address>;
+    getJettonAdminAddr(provider: ContractProvider, jettonMaster: Address): Promise<Address>;
+    getTokenAccount(provider: ContractProvider, tokenPairID: number): Promise<string>;
+    sendUserLock(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        smgID: string;
+        tokenPairID: number;
+        crossValue: bigint;
+        dstUserAccount: string;
+        client: WanTonClient | Blockchain;
+        senderAccount: string;
+        bridgeScAddr: string;
+    }, differentQueryID?: number): Promise<void>;
+    sendSmgRelease(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        uniqueID: bigint;
+        smgID: string;
+        tokenPairID: number;
+        releaseValue: bigint;
+        fee: bigint;
+        userAccount: Address;
+        bridgeJettonWalletAddr: Address;
+        e: bigint;
+        p: bigint;
+        s: bigint;
+        fwTonAmount: bigint;
+        totalTonAmount: bigint;
+    }): Promise<void>;
+    sendHalt(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        halt: number;
+    }): Promise<void>;
+    sendTransferCrossOwner(provider: ContractProvider, sender: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        owner: Address;
+    }): Promise<void>;
+    getCrossConfig(provider: ContractProvider): Promise<{
+        owner: Address;
+        halt: number;
+        init: number;
+        oracleAdmin: Address;
+        feeProxyAdmin: Address;
+        operator: Address;
+    }>;
+    getChainFee(provider: ContractProvider, srcChainId: number, dstChainId: number): Promise<{
+        contractFee: number;
+        agentFee: number;
+    }>;
+    getTokenPairFee(provider: ContractProvider, tokenpair: number): Promise<number>;
+    getTokenPair(provider: ContractProvider, tokenPairId: number): Promise<{
+        fromChainID: number;
+        toChainID: number;
+        fromAccount: string;
+        toAccount: string;
+        jettonAdminAddr: string;
+        walletCodeBase64: string;
+        exist: string;
+    }>;
+    getFirstTokenPairID(provider: ContractProvider): Promise<number>;
+    getNextTokenPairID(provider: ContractProvider, id: number): Promise<number>;
+    getFirstStoremanGroupID(provider: ContractProvider): Promise<bigint>;
+    getNextStoremanGroupID(provider: ContractProvider, id: bigint): Promise<bigint>;
+    getFirstStoremanGroupIDCommited(provider: ContractProvider): Promise<bigint>;
+    getNextStoremanGroupIDCommited(provider: ContractProvider, id: bigint): Promise<bigint>;
+    getStoremanGroupConfig(provider: ContractProvider, id: bigint): Promise<{
+        gpkX: bigint;
+        gpkY: bigint;
+        startTime: bigint;
+        endTime: bigint;
+    }>;
+    getStoremanGroupConfigCommited(provider: ContractProvider, id: bigint): Promise<{
+        gpkX: bigint;
+        gpkY: bigint;
+        startTime: bigint;
+        endTime: bigint;
+    }>;
+    sendSetStoremanGroupConfig(provider: ContractProvider, sender: Sender, opts: {
+        id: bigint;
+        gpkX: bigint;
+        gpkY: bigint;
+        startTime: number;
+        endTime: number;
+        value: bigint;
+        queryID?: number;
+    }): Promise<void>;
+    sendRemoveStoremanGroup(provider: ContractProvider, sender: Sender, opts: {
+        id: bigint;
+        value: bigint;
+        queryID?: number;
+    }): Promise<void>;
+    sendSetStoremanGroupConfigCommit(provider: ContractProvider, sender: Sender, opts: {
+        id: bigint;
+        gpkX: bigint;
+        gpkY: bigint;
+        startTime: number;
+        endTime: number;
+        value: bigint;
+        queryID?: number;
+    }): Promise<void>;
+    getBalance(provider: ContractProvider): Promise<bigint>;
+    sendAddAdmin(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        adminAddr: Address;
+    }): Promise<void>;
+    sendRemoveAdmin(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        adminAddr: Address;
+    }): Promise<void>;
+    sendSetFeeProxy(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        feeProxy: Address;
+    }): Promise<void>;
+    getFirstAdmin(provider: ContractProvider): Promise<string>;
+    getNextAdmin(provider: ContractProvider, adminAddr: Address): Promise<string>;
+    getUpdatedInt(provider: ContractProvider): Promise<number>;
+    sendUpdateInt(provider: ContractProvider, opts: {
+        sender: Sender;
+        value: bigint;
+        queryID?: number;
+    }): Promise<void>;
+    sendUpgradeSC(provider: ContractProvider, via: Sender, opts: {
+        value: bigint;
+        queryID?: number;
+        code: Cell;
+    }): Promise<void>;
+    getVersion(provider: ContractProvider): Promise<string>;
+}

package/dist/Bridge.js

@@ -0,0 +1,468 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bridge = void 0;
+exports.bridgeConfigToCell = bridgeConfigToCell;
+const logger_1 = require("./utils/logger");
+const formatUtil = require('util');
+const userLock_1 = require("./code/userLock");
+const core_1 = require("@ton/core");
+const JettonMinter_1 = require("./JettonMinter");
+const opcodes = __importStar(require("./opcodes"));
+const encode_decode_1 = require("./code/encode-decode");
+const const_value_1 = require("./const/const-value");
+function bridgeConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(config.owner)
+        // .storeAddress(config.admin)
+        .storeUint(config.halt, 2)
+        .storeUint(config.init, 2)
+        .storeRef((0, core_1.beginCell)() // *****about fee begin*****
+        .storeAddress(config.smgFeeProxy) // feeProxyAddress
+        .storeAddress(config.operator) // operator
+        .storeDict() // about Contract and Agent fee
+        .storeDict() // about tokenPairFee
+        .storeDict() // cross_admin
+        .endCell()) // *****about fee end*****
+        .storeRef((0, core_1.beginCell)() // *****about oracle begin*****
+        .storeAddress(config.oracleAdmin) // oracleAdmin
+        .storeDict() // mapSmgConfig
+        .storeDict() // mapSmgConfigCommit
+        .storeDict() // mapSmgTxStatus
+        .endCell()) // *****about oracle end*****
+        .storeRef((0, core_1.beginCell)() // *****about tm begin*****
+        .storeDict() // mapTokenPairInfo
+        //.storeDict() // mapWrappedToken
+        .endCell()) // *****about tm end*****
+        .storeRef((0, core_1.beginCell)()
+        .endCell()) // extended
+        .endCell();
+}
+class Bridge {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new Bridge(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = bridgeConfigToCell(config);
+        const init = { code, data };
+        return new Bridge((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(),
+        });
+    }
+    async sendSetTokenPairFee(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: encode_decode_1.codeTable[opcodes.OP_FEE_SetTokenPairFee].enCode(opts),
+        });
+    }
+    async sendSetTokenPairFees(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: encode_decode_1.codeTable[opcodes.OP_FEE_SetTokenPairFees].enCode(opts),
+        });
+    }
+    async sendSetChainFee(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: encode_decode_1.codeTable[opcodes.OP_FEE_SetChainFee].enCode(opts),
+        });
+    }
+    async sendSetChainFees(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: encode_decode_1.codeTable[opcodes.OP_FEE_SetChainFees].enCode(opts),
+        });
+    }
+    async sendAddTokenPair(provider, via, opts) {
+        let bodyHex = encode_decode_1.codeTable[opcodes.OP_TOKENPAIR_Upsert].enCode(opts).toBoc().toString('hex');
+        logger_1.logger.info(formatUtil.format("bodyHex %s", bodyHex));
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: encode_decode_1.codeTable[opcodes.OP_TOKENPAIR_Upsert].enCode(opts),
+        });
+    }
+    async sendRemoveTokenPair(provider, via, opts) {
+        let bodyCell = encode_decode_1.codeTable[opcodes.OP_TOKENPAIR_Remove].enCode(opts);
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: bodyCell,
+        });
+    }
+    async getJettonWalletAddr(provider, jettonMaster, owner) {
+        let c = JettonMinter_1.JettonMinter.createFromAddress(jettonMaster);
+        let jettonMinterScOpened = await provider.open(c);
+        return await jettonMinterScOpened.getWalletAddress(owner);
+    }
+    async getJettonAdminAddr(provider, jettonMaster) {
+        let c = JettonMinter_1.JettonMinter.createFromAddress(jettonMaster);
+        let jettonMinterScOpened = await provider.open(c);
+        return await jettonMinterScOpened.getAdminAddress();
+    }
+    async getTokenAccount(provider, tokenPairID) {
+        // 1. get tokenpair from bridge
+        let tokePairInfo = await this.getTokenPair(provider, tokenPairID);
+        logger_1.logger.info(formatUtil.format("tokePairInfo", tokePairInfo));
+        // 2. check src account and dst account
+        let tokenAccount = "";
+        if (tokePairInfo.fromChainID == const_value_1.BIP44_CHAINID) {
+            tokenAccount = tokePairInfo.fromAccount;
+        }
+        else {
+            if (tokePairInfo.toChainID == const_value_1.BIP44_CHAINID) {
+                tokenAccount = tokePairInfo.toAccount;
+            }
+            else {
+                throw "TokenPair not support";
+            }
+        }
+        return tokenAccount;
+    }
+    async sendUserLock(provider, via, opts, differentQueryID) {
+        let ret = await (0, userLock_1.buildUserLockMessages)({
+            value: opts.value,
+            smgID: opts.smgID,
+            tokenPairID: opts.tokenPairID,
+            crossValue: opts.crossValue,
+            dstUserAccount: opts.dstUserAccount,
+            bridgeScAddr: opts.bridgeScAddr,
+            client: opts.client,
+            senderAccount: opts.senderAccount
+        }, differentQueryID);
+        logger_1.logger.info("ret==>", ret);
+        logger_1.logger.info("ret.to==>", ret.to);
+        if (ret.to.toString() == this.address.toString()) {
+            logger_1.logger.info("entering lock coin");
+            let totalValue;
+            totalValue = ret.value;
+            await provider.internal(via, {
+                value: totalValue,
+                sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+                body: ret.body
+            });
+        }
+        else {
+            logger_1.logger.info("entering lock token");
+            let provider = await opts.client.provider(ret.to);
+            await provider.internal(via, {
+                value: opts.value,
+                //sendMode: SendMode.PAY_GAS_SEPARATELY,
+                sendMode: core_1.SendMode.NONE,
+                body: ret.body
+            });
+        }
+    }
+    async sendSmgRelease(provider, via, opts) {
+        logger_1.logger.info("opts1", opts);
+        let body = encode_decode_1.codeTable[opcodes.OP_CROSS_SmgRelease].enCode(opts);
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body
+        });
+    }
+    async sendHalt(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_COMMON_SetHalt, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.halt, 2)
+                .endCell(),
+        });
+    }
+    async sendTransferCrossOwner(provider, sender, opts) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_COMMON_TransferOwner, 32) // op (op #1 = increment)
+                .storeUint(opts.queryID ? opts.queryID : 0, 64) // query id
+                .storeAddress(opts.owner)
+                .endCell()
+        });
+    }
+    async getCrossConfig(provider) {
+        const common = await provider.get('get_cross_config', []);
+        let oracleAdmin = await provider.get('get_oracle_admin', []);
+        let feeConfig = await provider.get('get_fee_config', []);
+        return {
+            owner: common.stack.readAddress(),
+            halt: common.stack.readNumber(),
+            init: common.stack.readNumber(),
+            oracleAdmin: oracleAdmin.stack.readAddress(),
+            feeProxyAdmin: feeConfig.stack.readAddress(),
+            operator: feeConfig.stack.readAddress(),
+        };
+    }
+    async getChainFee(provider, srcChainId, dstChainId) {
+        const result = await provider.get('get_chain_fee', [{ type: 'int', value: BigInt(srcChainId) },
+            { type: 'int', value: BigInt(dstChainId) }]);
+        return {
+            contractFee: result.stack.readNumber(),
+            agentFee: result.stack.readNumber()
+        };
+    }
+    async getTokenPairFee(provider, tokenpair) {
+        const result = await provider.get('get_tokenpair_fee', [{ type: 'int', value: BigInt(tokenpair) }]);
+        return result.stack.readNumber();
+    }
+    async getTokenPair(provider, tokenPairId) {
+        const result = await provider.get('get_token_pair', [{ type: 'int', value: BigInt(tokenPairId) }]);
+        let fromChainID = result.stack.readNumber();
+        let fromAccount = result.stack.readBuffer();
+        let toChainID = result.stack.readNumber();
+        let toAccount = result.stack.readBuffer();
+        let jettonAdminAddr = result.stack.readBuffer();
+        let exist = 1;
+        if (result.stack.remaining) {
+            exist = result.stack.readNumber();
+        }
+        let walletCode = core_1.Cell.EMPTY;
+        if (result.stack.remaining) {
+            walletCode = result.stack.readCellOpt();
+        }
+        let pair = { fromChainID, toChainID, fromAccount: "", toAccount: "", jettonAdminAddr: "", walletCodeBase64: "", exist: "" };
+        if (pair.fromChainID == 0 || pair.toChainID == 0) {
+            return pair;
+        }
+        if (const_value_1.BIP44_CHAINID == fromChainID) {
+            let addr = new core_1.Address(0, fromAccount);
+            pair['fromAccount'] = addr.toString();
+            pair['toAccount'] = "0x" + toAccount.toString('hex');
+        }
+        else {
+            let addr = new core_1.Address(0, toAccount);
+            pair['toAccount'] = addr.toString();
+            pair['fromAccount'] = "0x" + fromAccount.toString('hex');
+        }
+        pair['exist'] = exist.toString();
+        pair['jettonAdminAddr'] = (new core_1.Address(0, jettonAdminAddr)).toString();
+        pair['walletCodeBase64'] = walletCode.toBoc().toString('base64');
+        return pair;
+    }
+    async getFirstTokenPairID(provider) {
+        const result = await provider.get('get_first_tokenpair_id', []);
+        // todo getTokenPair
+        return result.stack.readNumber();
+    }
+    async getNextTokenPairID(provider, id) {
+        const result = await provider.get('get_next_tokenpair_id', [{ type: 'int', value: BigInt(id) }]);
+        // todo getTokenPair
+        return result.stack.readNumber();
+    }
+    async getFirstStoremanGroupID(provider) {
+        const { stack } = await provider.get("get_first_smg_id", []);
+        return stack.readBigNumber();
+    }
+    async getNextStoremanGroupID(provider, id) {
+        const { stack } = await provider.get("get_next_smg_id", [{ type: 'int', value: id }]);
+        return stack.readBigNumber();
+    }
+    async getFirstStoremanGroupIDCommited(provider) {
+        const { stack } = await provider.get("get_first_smg_id_Commited", []);
+        return stack.readBigNumber();
+    }
+    async getNextStoremanGroupIDCommited(provider, id) {
+        const { stack } = await provider.get("get_next_smg_id_Commited", [{ type: 'int', value: id }]);
+        return stack.readBigNumber();
+    }
+    async getStoremanGroupConfig(provider, id) {
+        const { stack } = await provider.get("get_smgConfig", [{ type: 'int', value: id }]);
+        return {
+            gpkX: stack.readBigNumber(),
+            gpkY: stack.readBigNumber(),
+            startTime: stack.readBigNumber(),
+            endTime: stack.readBigNumber(),
+        };
+    }
+    async getStoremanGroupConfigCommited(provider, id) {
+        const { stack } = await provider.get("get_smgConfigCommited", [{ type: 'int', value: id }]);
+        return {
+            gpkX: stack.readBigNumber(),
+            gpkY: stack.readBigNumber(),
+            startTime: stack.readBigNumber(),
+            endTime: stack.readBigNumber(),
+        };
+    }
+    async sendSetStoremanGroupConfig(provider, sender, opts) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_ORACLE_SetSMG, 32)
+                .storeUint(0, 64) // query id
+                .storeUint(opts.id, 256)
+                .storeUint(opts.gpkX, 256)
+                .storeUint(opts.gpkY, 256)
+                .storeUint(opts.startTime, 64)
+                .storeUint(opts.endTime, 64)
+                .endCell()
+        });
+    }
+    async sendRemoveStoremanGroup(provider, sender, opts) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_ORACLE_DeleteSMG, 32)
+                .storeUint(0, 64) // query id
+                .storeUint(opts.id, 256)
+                .endCell()
+        });
+    }
+    async sendSetStoremanGroupConfigCommit(provider, sender, opts) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_ORACLE_CommitSMG, 32)
+                .storeUint(0, 64) // query id
+                .storeUint(opts.id, 256)
+                .storeUint(opts.gpkX, 256)
+                .storeUint(opts.gpkY, 256)
+                .storeUint(opts.startTime, 64)
+                .storeUint(opts.endTime, 64)
+                .endCell()
+        });
+    }
+    async getBalance(provider) {
+        let state = await provider.getState();
+        return state.balance;
+    }
+    async sendAddAdmin(provider, via, opts) {
+        let isValid = core_1.Address.isAddress(opts.adminAddr);
+        if (!isValid) {
+            await Promise.reject("in valid address");
+        }
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_FEE_AddCrossAdmin, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeAddress(opts.adminAddr)
+                .endCell(),
+        });
+    }
+    async sendRemoveAdmin(provider, via, opts) {
+        let isValid = core_1.Address.isAddress(opts.adminAddr);
+        if (!isValid) {
+            await Promise.reject("in valid address");
+        }
+        return await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_FEE_DelCrossAdmin, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeAddress(opts.adminAddr)
+                .endCell(),
+        });
+    }
+    async sendSetFeeProxy(provider, via, opts) {
+        let isValid = core_1.Address.isAddress(opts.feeProxy);
+        if (!isValid) {
+            await Promise.reject("in valid address");
+        }
+        return await provider.internal(via, {
+            value: opts.value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_FEE_SetSmgFeeProxy, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeAddress(opts.feeProxy)
+                .endCell(),
+        });
+    }
+    async getFirstAdmin(provider) {
+        const { stack } = await provider.get("get_first_crossAdmin", []);
+        let s = stack.readBuffer();
+        if (s.toString('hex') == '0000000000000000000000000000000000000000000000000000000000000000') {
+            return "";
+        }
+        let addr = new core_1.Address(0, s);
+        return addr.toString();
+    }
+    async getNextAdmin(provider, adminAddr) {
+        const { stack } = await provider.get("get_next_crossAdmin", [{ type: 'slice', cell: (0, core_1.beginCell)().storeAddress(adminAddr).endCell() }]);
+        let s = stack.readBuffer();
+        if (s.toString('hex') == '0000000000000000000000000000000000000000000000000000000000000000') {
+            return "";
+        }
+        let addr = new core_1.Address(0, s);
+        return addr.toString();
+    }
+    // for upgrade sc test
+    async getUpdatedInt(provider) {
+        const result = await provider.get('get_updated_int', []);
+        return result.stack.readNumber();
+    }
+    async sendUpdateInt(provider, opts) {
+        await provider.internal(opts.sender, {
+            value: opts.value,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_EXTEND_UpdateAddInt, 32) // op (op #1 = increment)
+                .storeUint(0, 64) // query id
+                .endCell()
+        });
+    }
+    async sendUpgradeSC(provider, via, opts) {
+        await provider.internal(via, {
+            value: opts.value,
+            body: (0, core_1.beginCell)()
+                .storeUint(opcodes.OP_UPGRADE_Code, 32) // op (op #1 = increment)
+                .storeUint(0, 64) // query id
+                .storeRef(opts.code)
+                .endCell()
+        });
+    }
+    async getVersion(provider) {
+        const result = await provider.get('version', []);
+        return result.stack.readString();
+    }
+}
+exports.Bridge = Bridge;

package/dist/Fake.compile.d.ts

@@ -0,0 +1,2 @@
+import { CompilerConfig } from '@ton/blueprint';
+export declare const compile: CompilerConfig;