wan-ton-sdk 0.0.7 → 0.0.9

package/GroupApprove.ts

@@ -1,274 +0,0 @@
-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

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

package/JettonMinter.ts

@@ -1,135 +0,0 @@
-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

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

package/JettonWallet.ts

@@ -1,127 +0,0 @@
-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/Signature.compile.ts

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

package/Signature.ts

@@ -1,105 +0,0 @@
-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

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