@metoncash/sdk-v1 0.1.0

package/dist/wrappers/JettonWallet.gen.d.ts

@@ -0,0 +1,308 @@
+import * as c from '@ton/core';
+import { ContractProvider, Sender, SendMode } from '@ton/core';
+type RemainingBitsAndRefs = c.Slice;
+export type CellRef<T> = {
+    ref: T;
+};
+type coins = bigint;
+type uint64 = bigint;
+/**
+ > struct JettonWalletStorage {
+ >     balance: coins
+ >     owner: address
+ >     master: address
+ > }
+ */
+export interface JettonWalletStorage {
+    readonly $: 'JettonWalletStorage';
+    balance: coins;
+    owner: c.Address;
+    master: c.Address;
+}
+export declare const JettonWalletStorage: {
+    create(args: {
+        balance?: coins;
+        owner: c.Address;
+        master: c.Address;
+    }): JettonWalletStorage;
+    fromSlice(s: c.Slice): JettonWalletStorage;
+    store(self: JettonWalletStorage, b: c.Builder): void;
+    toCell(self: JettonWalletStorage): c.Cell;
+};
+/**
+ > struct JettonWalletStorageRuntime {
+ >     balance: coins
+ >     owner: address
+ >     master: address
+ > }
+ */
+export interface JettonWalletStorageRuntime {
+    readonly $: 'JettonWalletStorageRuntime';
+    balance: coins;
+    owner: c.Address;
+    master: c.Address;
+}
+export declare const JettonWalletStorageRuntime: {
+    create(args: {
+        balance: coins;
+        owner: c.Address;
+        master: c.Address;
+    }): JettonWalletStorageRuntime;
+    fromSlice(s: c.Slice): JettonWalletStorageRuntime;
+    store(self: JettonWalletStorageRuntime, b: c.Builder): void;
+    toCell(self: JettonWalletStorageRuntime): c.Cell;
+};
+/**
+ > struct (0x0f8a7ea5) JettonTransfer {
+ >     queryId: uint64
+ >     jettonAmount: coins
+ >     transferRecipient: address
+ >     sendExcessesTo: address?
+ >     customPayload: cell?
+ >     forwardTonAmount: coins
+ >     forwardPayload: RemainingBitsAndRefs
+ > }
+ */
+export interface JettonTransfer {
+    readonly $: 'JettonTransfer';
+    queryId: uint64;
+    jettonAmount: coins;
+    transferRecipient: c.Address;
+    sendExcessesTo: c.Address | null;
+    customPayload: c.Cell | null;
+    forwardTonAmount: coins;
+    forwardPayload: RemainingBitsAndRefs;
+}
+export declare const JettonTransfer: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonAmount: coins;
+        transferRecipient: c.Address;
+        sendExcessesTo: c.Address | null;
+        customPayload: c.Cell | null;
+        forwardTonAmount: coins;
+        forwardPayload: RemainingBitsAndRefs;
+    }): JettonTransfer;
+    fromSlice(s: c.Slice): JettonTransfer;
+    store(self: JettonTransfer, b: c.Builder): void;
+    toCell(self: JettonTransfer): c.Cell;
+};
+/**
+ > struct (0x7362d09c) JettonTransferNotification {
+ >     queryId: uint64
+ >     jettonAmount: coins
+ >     from: address
+ >     forwardPayload: RemainingBitsAndRefs
+ > }
+ */
+export interface JettonTransferNotification {
+    readonly $: 'JettonTransferNotification';
+    queryId: uint64;
+    jettonAmount: coins;
+    from: c.Address;
+    forwardPayload: RemainingBitsAndRefs;
+}
+export declare const JettonTransferNotification: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonAmount: coins;
+        from: c.Address;
+        forwardPayload: RemainingBitsAndRefs;
+    }): JettonTransferNotification;
+    fromSlice(s: c.Slice): JettonTransferNotification;
+    store(self: JettonTransferNotification, b: c.Builder): void;
+    toCell(self: JettonTransferNotification): c.Cell;
+};
+/**
+ > struct (0x178d4519) JettonInternalTransfer {
+ >     queryId: uint64
+ >     jettonAmount: coins
+ >     transferInitiator: address
+ >     sendExcessesTo: address?
+ >     forwardTonAmount: coins
+ >     forwardPayload: RemainingBitsAndRefs
+ > }
+ */
+export interface JettonInternalTransfer {
+    readonly $: 'JettonInternalTransfer';
+    queryId: uint64;
+    jettonAmount: coins;
+    transferInitiator: c.Address;
+    sendExcessesTo: c.Address | null;
+    forwardTonAmount: coins;
+    forwardPayload: RemainingBitsAndRefs;
+}
+export declare const JettonInternalTransfer: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonAmount: coins;
+        transferInitiator: c.Address;
+        sendExcessesTo: c.Address | null;
+        forwardTonAmount: coins;
+        forwardPayload: RemainingBitsAndRefs;
+    }): JettonInternalTransfer;
+    fromSlice(s: c.Slice): JettonInternalTransfer;
+    store(self: JettonInternalTransfer, b: c.Builder): void;
+    toCell(self: JettonInternalTransfer): c.Cell;
+};
+/**
+ > struct (0xd53276db) JettonExcesses {
+ >     queryId: uint64
+ > }
+ */
+export interface JettonExcesses {
+    readonly $: 'JettonExcesses';
+    queryId: uint64;
+}
+export declare const JettonExcesses: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+    }): JettonExcesses;
+    fromSlice(s: c.Slice): JettonExcesses;
+    store(self: JettonExcesses, b: c.Builder): void;
+    toCell(self: JettonExcesses): c.Cell;
+};
+/**
+ > struct (0x595f07bc) JettonBurn {
+ >     queryId: uint64
+ >     jettonAmount: coins
+ >     sendExcessesTo: address?
+ >     customPayload: cell?
+ > }
+ */
+export interface JettonBurn {
+    readonly $: 'JettonBurn';
+    queryId: uint64;
+    jettonAmount: coins;
+    sendExcessesTo: c.Address | null;
+    customPayload: c.Cell | null;
+}
+export declare const JettonBurn: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonAmount: coins;
+        sendExcessesTo: c.Address | null;
+        customPayload: c.Cell | null;
+    }): JettonBurn;
+    fromSlice(s: c.Slice): JettonBurn;
+    store(self: JettonBurn, b: c.Builder): void;
+    toCell(self: JettonBurn): c.Cell;
+};
+/**
+ > struct (0x7bdd97de) JettonBurnNotification {
+ >     queryId: uint64
+ >     jettonAmount: coins
+ >     burnInitiator: address
+ >     sendExcessesTo: address?
+ > }
+ */
+export interface JettonBurnNotification {
+    readonly $: 'JettonBurnNotification';
+    queryId: uint64;
+    jettonAmount: coins;
+    burnInitiator: c.Address;
+    sendExcessesTo: c.Address | null;
+}
+export declare const JettonBurnNotification: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonAmount: coins;
+        burnInitiator: c.Address;
+        sendExcessesTo: c.Address | null;
+    }): JettonBurnNotification;
+    fromSlice(s: c.Slice): JettonBurnNotification;
+    store(self: JettonBurnNotification, b: c.Builder): void;
+    toCell(self: JettonBurnNotification): c.Cell;
+};
+interface ExtraSendOptions {
+    bounce?: boolean;
+    sendMode?: SendMode;
+    extraCurrencies?: c.ExtraCurrency;
+}
+interface DeployedAddrOptions {
+    workchain?: number;
+    toShard?: {
+        fixedPrefixLength: number;
+        closeTo: c.Address;
+    };
+    overrideContractCode?: c.Cell;
+}
+export declare class JettonWallet implements c.Contract {
+    static Errors: {
+        ERR_INSUFFICIENT_BALANCE: number;
+        ERR_NOT_OWNER: number;
+        ERR_NOT_VALID_SOURCE: number;
+        'Errors.InvalidWorkchain': number;
+    };
+    readonly address: c.Address;
+    readonly init: {
+        code: c.Cell;
+        data: c.Cell;
+    } | undefined;
+    protected constructor(address: c.Address, init?: {
+        code: c.Cell;
+        data: c.Cell;
+    });
+    static fromAddress(address: c.Address): JettonWallet;
+    static createCellOfJettonTransfer(body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        transferRecipient: c.Address;
+        sendExcessesTo: c.Address | null;
+        customPayload: c.Cell | null;
+        forwardTonAmount: coins;
+        forwardPayload: RemainingBitsAndRefs;
+    }): c.Cell;
+    static createCellOfJettonInternalTransfer(body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        transferInitiator: c.Address;
+        sendExcessesTo: c.Address | null;
+        forwardTonAmount: coins;
+        forwardPayload: RemainingBitsAndRefs;
+    }): c.Cell;
+    static createCellOfJettonBurn(body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        sendExcessesTo: c.Address | null;
+        customPayload: c.Cell | null;
+    }): c.Cell;
+    sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendJettonTransfer(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        transferRecipient: c.Address;
+        sendExcessesTo: c.Address | null;
+        customPayload: c.Cell | null;
+        forwardTonAmount: coins;
+        forwardPayload: RemainingBitsAndRefs;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendJettonInternalTransfer(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        transferInitiator: c.Address;
+        sendExcessesTo: c.Address | null;
+        forwardTonAmount: coins;
+        forwardPayload: RemainingBitsAndRefs;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendJettonBurn(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        sendExcessesTo: c.Address | null;
+        customPayload: c.Cell | null;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    getWalletStorage(provider: ContractProvider): Promise<JettonWalletStorageRuntime>;
+    getWalletData(provider: ContractProvider): Promise<[
+        coins,
+        c.Address,
+        c.Address,
+        c.Cell
+    ]>;
+}
+export {};