wan-ton-sdk 0.0.6

package/GroupApprove.ts

@@ -0,0 +1,274 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode, Slice } from '@ton/core';
+import * as opcodes from  "./opcodes";
+import { HttpApi } from '@ton/ton';
+import { getHttpEndpoint } from "@orbs-network/ton-access";
+import internal from 'stream';
+
+import {BIP44_CHAINID} from './const/const-value';
+import {codeTable} from "./code/encode-decode";
+
+import {logger} from './utils/logger'
+import {OP_GROUPAPPROVE_Proposol_TransferOwner} from "./opcodes";
+const formatUtil = require('util');
+
+
+
+export type GroupApproveConfig = {
+    chainId: number;
+    taskId:  number;
+    foundation: Address;
+    bridge: Address;
+};
+
+export function GroupApproveConfigToCell(config: GroupApproveConfig): Cell {
+    return beginCell()
+        .storeUint(config.taskId, 256)
+        .storeAddress(config.foundation)
+        .storeAddress(config.bridge)
+        .storeDict()
+        .endCell();
+}
+
+
+export class GroupApprove implements Contract {
+    constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+    static createFromAddress(address: Address) {
+        return new GroupApprove(address);
+    }
+
+    static createFromConfig(config: GroupApproveConfig, code: Cell) {
+        const data = GroupApproveConfigToCell(config);
+        const init = { code, data };
+        return new GroupApprove(contractAddress(0, init), init);
+    }
+
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            body: beginCell().endCell(),
+        });
+    }
+
+    async sendTransferCrossOwner(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            owner: Address,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_TransferOwner].enCode(opts)
+        });
+    }
+    async sendTransferOracleAdmin(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            oracleAdmin: Address,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_TransferOracleAdmin].enCode(opts)
+        });
+    }    
+    async sendTransferRobotAdmin(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            operator: Address,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_TransferOperator].enCode(opts)
+        });
+    }      
+    async sendTransferFoundation(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            foundation: Address,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_TranferFoundation].enCode(opts)
+        });
+        
+    }       
+    async sendCrossHalt(
+        provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            halt: number,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_SetHalt].enCode(opts)
+        });
+    }    
+    async sendAddCrossAdmin(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            admin: Address,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_AddCrossAdmin].enCode(opts)
+        });
+    }    
+    async sendRemoveCrossAdmin(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            admin: Address,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_DelCrossAdmin].enCode(opts)
+        });
+    }   
+    async sendAddTokenPair(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            tokenPairId:number,
+            fromChainID:number,
+            fromAccount:string,
+            toChainID:number,
+            toAccount:string,
+            jettonAdminAddr:string
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_TOKENPAIR_Upsert].enCode(opts)
+        });
+    }    
+    async sendRemoveTokenPair(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            tokenPairId: number,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_TOKENPAIR_Remove].enCode(opts)
+        });
+    }      
+    async sendSetFeeProxy(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,
+            feeProxy: Address,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_SetSmgFeeProxy].enCode(opts)
+        });
+    }        
+    async sendUpgradeSC(provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            chainId:number,
+            toAddr: Address,            
+            code: Cell,
+        }
+    ) {
+        await provider.internal(sender, {
+            value: opts.value,
+            body: codeTable[opcodes.OP_GROUPAPPROVE_Proposol_UpgradeSc].enCode(opts)
+        });
+    }   
+
+    async sendApproveExec(
+        provider: ContractProvider, sender: Sender,
+        opts: {
+            value: bigint,
+            queryID?: number,
+            taskId: number,
+            smgId: bigint,
+            e:bigint,
+            p:bigint,
+            s:bigint,
+        }
+    ) {
+        let proof = beginCell()
+        .storeUint(opts.e, 256)
+        .storeUint(opts.p, 256)
+        .storeUint(opts.s, 256)
+        .endCell();
+        await provider.internal(sender, {
+            value: opts.value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell()
+                .storeUint(opcodes.OP_GROUPAPPROVE_Execute, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.smgId, 256)
+                .storeUint(opts.taskId,64)
+                .storeRef(proof)
+                .endCell(),
+        });
+    }
+    async getProposolCount(provider: ContractProvider) {
+        const result = await provider.get('get_proposol_count', []);
+        return result.stack.readNumber()
+    }
+    async getConfig(provider: ContractProvider) {
+        const result = await provider.get('get_config', []);
+        let foundation = result.stack.readAddress();
+        let bridge = result.stack.readAddress();
+        return {
+            foundation, bridge
+        }
+    }    
+    async getProposolById(provider: ContractProvider, id: bigint) {
+        const result = await provider.get('get_proposol', [{ type: 'int', value: id }]);
+        return {
+            toAddr: result.stack.readAddress(),
+            msg:result.stack.readCell().asSlice(),
+            executed: result.stack.readNumber()
+        }
+    }   
+    
+    static computeHash(proposolId:bigint, currentChainId: bigint) {
+        let msg = beginCell()
+            .storeUint(proposolId, 64)
+            .storeUint(currentChainId, 32)
+            .endCell()
+
+        return msg.hash();
+    } 
+}

package/JettonMinter.compile.ts

@@ -0,0 +1,5 @@
+import { CompilerConfig } from '@ton/blueprint';
+
+export const compile: CompilerConfig = {
+    targets: ['contracts/jetton/jetton-minter.func'],
+};

package/JettonMinter.ts

@@ -0,0 +1,135 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode, toNano } from '@ton/core';
+
+export type JettonMinterContent = {
+    type:0|1,
+    uri:string
+};
+export type JettonMinterConfig = {admin: Address; content: Cell; wallet_code: Cell};
+
+export function jettonMinterConfigToCell(config: JettonMinterConfig): Cell {
+    return beginCell()
+                      .storeCoins(0)
+                      .storeAddress(config.admin)
+                      .storeRef(config.content)
+                      .storeRef(config.wallet_code)
+           .endCell();
+}
+
+export function jettonContentToCell(content:JettonMinterContent) {
+    return beginCell()
+                      .storeUint(content.type, 8)
+                      .storeStringTail(content.uri) //Snake logic under the hood
+           .endCell();
+}
+
+export class JettonMinter implements Contract {
+    constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+    static createFromAddress(address: Address) {
+        return new JettonMinter(address);
+    }
+
+    static createFromConfig(config: JettonMinterConfig, code: Cell, workchain = 0) {
+        const data = jettonMinterConfigToCell(config);
+        const init = { code, data };
+        return new JettonMinter(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    static mintMessage(to: Address, jetton_amount: bigint, forward_ton_amount: bigint, total_ton_amount: bigint,) {
+        return beginCell().storeUint(0x1674b0a0, 32).storeUint(0, 64) // op, queryId
+                          .storeAddress(to).storeCoins(jetton_amount)
+                          .storeCoins(forward_ton_amount).storeCoins(total_ton_amount)
+               .endCell();
+    }
+    async sendMint(provider: ContractProvider, via: Sender, to: Address, jetton_amount: bigint, forward_ton_amount: bigint, total_ton_amount: bigint,) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: JettonMinter.mintMessage(to, jetton_amount, forward_ton_amount, total_ton_amount,),
+            value: total_ton_amount + toNano("0.1"),
+        });
+    }
+
+    /* provide_wallet_address#2c76b973 query_id:uint64 owner_address:MsgAddress include_address:Bool = InternalMsgBody;
+    */
+    static discoveryMessage(owner: Address, include_address: boolean) {
+        return beginCell().storeUint(0x2c76b973, 32).storeUint(0, 64) // op, queryId
+                          .storeAddress(owner).storeBit(include_address)
+               .endCell();
+    }
+
+    async sendDiscovery(provider: ContractProvider, via: Sender, owner: Address, include_address: boolean, value:bigint = toNano('0.1')) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: JettonMinter.discoveryMessage(owner, include_address),
+            value: value,
+        });
+    }
+
+    static changeAdminMessage(newOwner: Address) {
+        return beginCell().storeUint(0x4840664f, 32).storeUint(0, 64) // op, queryId
+                          .storeAddress(newOwner)
+               .endCell();
+    }
+
+    async sendChangeAdmin(provider: ContractProvider, via: Sender, newOwner: Address) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: JettonMinter.changeAdminMessage(newOwner),
+            value: toNano("0.1"),
+        });
+    }
+    static changeContentMessage(content: Cell) {
+        return beginCell().storeUint(0x5773d1f5, 32).storeUint(0, 64) // op, queryId
+                          .storeRef(content)
+               .endCell();
+    }
+
+    async sendChangeContent(provider: ContractProvider, via: Sender, content: Cell) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: JettonMinter.changeContentMessage(content),
+            value: toNano("0.1"),
+        });
+    }
+    async getWalletAddress(provider: ContractProvider, owner: Address): Promise<Address> {
+        const res = await provider.get('get_wallet_address', [{ type: 'slice', cell: beginCell().storeAddress(owner).endCell() }])
+        return res.stack.readAddress()
+    }
+
+    async getJettonData(provider: ContractProvider) {
+        let res = await provider.get('get_jetton_data', []);
+        let totalSupply = res.stack.readBigNumber();
+        let mintable = res.stack.readBoolean();
+        let adminAddress = res.stack.readAddress();
+        let content = res.stack.readCell();
+        let walletCode = res.stack.readCell();
+        return {
+            totalSupply,
+            mintable,
+            adminAddress,
+            content,
+            walletCode
+        };
+    }
+
+    async getTotalSupply(provider: ContractProvider) {
+        let res = await this.getJettonData(provider);
+        return res.totalSupply;
+    }
+    async getAdminAddress(provider: ContractProvider) {
+        let res = await this.getJettonData(provider);
+        return res.adminAddress;
+    }
+    async getContent(provider: ContractProvider) {
+        let res = await this.getJettonData(provider);
+        return res.content;
+    }
+}

package/JettonWallet.compile.ts

@@ -0,0 +1,5 @@
+import { CompilerConfig } from '@ton/blueprint';
+
+export const compile: CompilerConfig = {
+    targets: ['contracts/jetton/jetton-wallet.func'],
+};

package/JettonWallet.ts

@@ -0,0 +1,127 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode, toNano } from '@ton/core';
+
+
+export type JettonWalletConfig = {};
+
+export function jettonWalletConfigToCell(config: JettonWalletConfig): Cell {
+    return beginCell().endCell();
+}
+
+export class JettonWallet implements Contract {
+    constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+    static createFromAddress(address: Address) {
+        return new JettonWallet(address);
+    }
+
+    static createFromConfig(config: JettonWalletConfig, code: Cell, workchain = 0) {
+        const data = jettonWalletConfigToCell(config);
+        const init = { code, data };
+        return new JettonWallet(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    async getJettonBalance(provider: ContractProvider) {
+        let state = await provider.getState();
+        if (state.state.type !== 'active') {
+            return 0n;
+        }
+        let res = await provider.get('get_wallet_data', []);
+        return res.stack.readBigNumber();
+    }
+    static transferMessage(jetton_amount: bigint, to: Address,
+                           responseAddress:Address,
+                           customPayload: Cell,
+                           forward_ton_amount: bigint,
+                           forwardPayload: Cell) {
+        return beginCell().storeUint(0xf8a7ea5, 32).storeUint(0, 64) // op, queryId
+                          .storeCoins(jetton_amount).storeAddress(to)
+                          .storeAddress(responseAddress)
+                          .storeMaybeRef(customPayload)
+                          .storeCoins(forward_ton_amount)
+                          .storeMaybeRef(forwardPayload)
+               .endCell();
+    }
+    async sendTransfer(provider: ContractProvider, via: Sender,
+                              value: bigint,
+                              jetton_amount: bigint,
+                              to: Address,
+                              responseAddress:Address,
+                              customPayload: Cell,
+                              forward_ton_amount: bigint,
+                              forwardPayload: Cell) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: JettonWallet.transferMessage(jetton_amount, to, responseAddress, customPayload, forward_ton_amount, forwardPayload),
+            value:value
+        });
+
+    }
+    /*
+      burn#595f07bc query_id:uint64 amount:(VarUInteger 16)
+                    response_destination:MsgAddress custom_payload:(Maybe ^Cell)
+                    = InternalMsgBody;
+    */
+    static burnMessage(jetton_amount: bigint,
+                       responseAddress:Address,
+                       customPayload: Cell) {
+        return beginCell().storeUint(0x595f07bc, 32).storeUint(0, 64) // op, queryId
+                          .storeCoins(jetton_amount).storeAddress(responseAddress)
+                          .storeMaybeRef(customPayload)
+               .endCell();
+    }
+
+    async sendBurn(provider: ContractProvider, via: Sender, value: bigint,
+                          jetton_amount: bigint,
+                          responseAddress:Address,
+                          customPayload: Cell) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: JettonWallet.burnMessage(jetton_amount, responseAddress, customPayload),
+            value:value
+        });
+
+    }
+    /*
+      withdraw_tons#107c49ef query_id:uint64 = InternalMsgBody;
+    */
+    static withdrawTonsMessage() {
+        return beginCell().storeUint(0x6d8e5e3c, 32).storeUint(0, 64) // op, queryId
+               .endCell();
+    }
+
+    async sendWithdrawTons(provider: ContractProvider, via: Sender) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: JettonWallet.withdrawTonsMessage(),
+            value:toNano('0.1')
+        });
+
+    }
+    /*
+      withdraw_jettons#10 query_id:uint64 wallet:MsgAddressInt amount:Coins = InternalMsgBody;
+    */
+    static withdrawJettonsMessage(from:Address, amount:bigint) {
+        return beginCell().storeUint(0x768a50b2, 32).storeUint(0, 64) // op, queryId
+                          .storeAddress(from)
+                          .storeCoins(amount)
+                          .storeMaybeRef(null)
+               .endCell();
+    }
+
+    async sendWithdrawJettons(provider: ContractProvider, via: Sender, from:Address, amount:bigint) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: JettonWallet.withdrawJettonsMessage(from, amount),
+            value:toNano('0.1')
+        });
+
+    }
+}

package/README.md

@@ -0,0 +1,24 @@
+# content of the sub directory
+## client: used for get random http endpoint
+## code  : decode encode emit event
+## contractAccess: used for read cross contract
+## event: interface for get event
+## sign: used hash data for mpc signature
+## wallet: interface about wallet contract. (currently support version4)
+
+# interface of the contract (same as the ABI of the contract)
+## Bridge.ts : include all the read and write interface of Bridge contract
+## GroupApprove.ts:   include all the interface of groupApprove
+
+# example (file name end with *-ex)
+## getTokenPair-ex.ts:  example of read contract
+## addTokenPair-ex.ts:  example of write contract
+## getEvent-ex.ts:      example of scan blockchain to get the event list.
+
+# how to start?
+## step 1: npm i wan-ton-bridge
+## step 2: reference of the example directory.
+
+# Attention
+## This SDK only support contract v4 of wallet.
+## If you need more version of wallet contract, you can reference TonWeb SDK.

package/Signature.compile.ts

@@ -0,0 +1,6 @@
+import { CompilerConfig } from '@ton/blueprint';
+
+export const compile: CompilerConfig = {
+    lang: 'func',
+    targets: ['contracts/signature.fc'],
+};

package/Signature.ts

@@ -0,0 +1,105 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from '@ton/core';
+import * as opcodes from  "./opcodes";
+
+export type SignatureConfig = {
+    id: number;
+    counter: number;
+};
+
+export function signatureConfigToCell(config: SignatureConfig): Cell {
+    return beginCell().endCell();
+}
+
+export const Opcodes = {
+    verify: 0x7e8764ef, //todo should update verify
+    verifyEcdsa:0x7e8764ee,
+};
+
+export class Signature implements Contract {
+    constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+    static createFromAddress(address: Address) {
+        return new Signature(address);
+    }
+
+    static createFromConfig(config: SignatureConfig, code: Cell, workchain = 0) {
+        const data = signatureConfigToCell(config);
+        const init = { code, data };
+        return new Signature(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    async sendVerify(
+        provider: ContractProvider,
+        via: Sender,
+        opts: {
+            s:bigint,
+            gpk_x:bigint,
+            gpk_y:bigint,
+            e:bigint,
+            p:bigint,
+            msg:bigint,
+            value: bigint;
+            queryID?: number;
+        }
+    ) {
+        let extraCell = beginCell()
+            .storeUint(opts.e, 256)
+            .storeUint(opts.p, 256)
+            .storeUint(opts.msg, 256)
+            .endCell()
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell()
+                .storeUint(opcodes.OP_SIG_Verify, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.s, 256)
+                .storeUint(opts.gpk_x, 256)
+                .storeUint(opts.gpk_y, 256)
+                .storeRef(extraCell)
+                .endCell(),
+        });
+    }
+
+    async sendVerifyEcdsa(
+        provider: ContractProvider,
+        via: Sender,
+        opts: {
+            s:bigint,
+            gpk_x:bigint,
+            gpk_y:bigint,
+            e:bigint,
+            p:bigint,
+            msg:bigint,
+            value: bigint;
+            queryID?: number;
+        }
+    ) {
+        let extraCell = beginCell()
+            .storeUint(opts.e, 256)
+            .storeUint(opts.p, 256)
+            .storeUint(opts.msg, 256)
+            .endCell()
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell()
+                .storeUint(opcodes.OP_SIG_VerifyEcdsa, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.s, 256)
+                .storeUint(opts.gpk_x, 256)
+                .storeUint(opts.gpk_y, 256)
+                .storeRef(extraCell)
+                .endCell(),
+        });
+    }
+
+}

package/address.compile.ts

@@ -0,0 +1,8 @@
+import { CompilerConfig } from '@ton/blueprint';
+
+export const compile: CompilerConfig = {
+    lang: 'func',
+    targets: [
+        'contracts/address.fc',
+    ],
+};