@metoncash/sdk-v1 0.1.0

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

@@ -0,0 +1,511 @@
+import * as c from '@ton/core';
+import { ContractProvider, Sender, SendMode } from '@ton/core';
+type RemainingBitsAndRefs = c.Slice;
+export type any_address = c.Address | c.ExternalAddress | 'none';
+export type CellRef<T> = {
+    ref: T;
+};
+type coins = bigint;
+type uint32 = bigint;
+type uint64 = bigint;
+type uint256 = bigint;
+/**
+ > 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 (0xd53276db) ExcessMessage {
+ >     queryId: uint64
+ > }
+ */
+export interface ExcessMessage {
+    readonly $: 'ExcessMessage';
+    queryId: uint64;
+}
+export declare const ExcessMessage: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+    }): ExcessMessage;
+    fromSlice(s: c.Slice): ExcessMessage;
+    store(self: ExcessMessage, b: c.Builder): void;
+    toCell(self: ExcessMessage): c.Cell;
+};
+/**
+ > struct MinterRuntimeStorage {
+ >     id: uint32
+ >     factory: address
+ >     manager: address
+ >     jettonMinter: address
+ >     jettonBalace: coins
+ >     jettonWallet: address?
+ >     walletCode: cell
+ > }
+ */
+export interface MinterRuntimeStorage {
+    readonly $: 'MinterRuntimeStorage';
+    id: uint32;
+    factory: c.Address;
+    manager: c.Address;
+    jettonMinter: c.Address;
+    jettonBalace: coins;
+    jettonWallet: c.Address | null;
+    walletCode: c.Cell;
+}
+export declare const MinterRuntimeStorage: {
+    create(args: {
+        id: uint32;
+        factory: c.Address;
+        manager: c.Address;
+        jettonMinter: c.Address;
+        jettonBalace: coins;
+        jettonWallet: c.Address | null;
+        walletCode: c.Cell;
+    }): MinterRuntimeStorage;
+    fromSlice(s: c.Slice): MinterRuntimeStorage;
+    store(self: MinterRuntimeStorage, b: c.Builder): void;
+    toCell(self: MinterRuntimeStorage): c.Cell;
+};
+/**
+ > struct MinterStorageAdditionalData {
+ >     jettonBalace: coins
+ >     jettonWallet: address?
+ > }
+ */
+export interface MinterStorageAdditionalData {
+    readonly $: 'MinterStorageAdditionalData';
+    jettonBalace: coins;
+    jettonWallet: c.Address | null;
+}
+export declare const MinterStorageAdditionalData: {
+    create(args: {
+        jettonBalace?: coins;
+        jettonWallet?: c.Address | null;
+    }): MinterStorageAdditionalData;
+    fromSlice(s: c.Slice): MinterStorageAdditionalData;
+    store(self: MinterStorageAdditionalData, b: c.Builder): void;
+    toCell(self: MinterStorageAdditionalData): c.Cell;
+};
+/**
+ > struct MinterStorage {
+ >     id: uint32
+ >     factory: address
+ >     manager: address
+ >     jettonMinter: address
+ >     additionalData: Cell<MinterStorageAdditionalData>
+ >     walletCode: cell
+ > }
+ */
+export interface MinterStorage {
+    readonly $: 'MinterStorage';
+    id: uint32;
+    factory: c.Address;
+    manager: c.Address;
+    jettonMinter: c.Address;
+    additionalData: CellRef<MinterStorageAdditionalData>;
+    walletCode: c.Cell;
+}
+export declare const MinterStorage: {
+    create(args: {
+        id: uint32;
+        factory: c.Address;
+        manager: c.Address;
+        jettonMinter: c.Address;
+        additionalData: CellRef<MinterStorageAdditionalData>;
+        walletCode: c.Cell;
+    }): MinterStorage;
+    fromSlice(s: c.Slice): MinterStorage;
+    store(self: MinterStorage, b: c.Builder): void;
+    toCell(self: MinterStorage): c.Cell;
+};
+/**
+ > struct (0x537e7304) InternalInitMinter {
+ >     queryId: uint64
+ >     jettonWallet: address
+ >     excesses: address
+ > }
+ */
+export interface InternalInitMinter {
+    readonly $: 'InternalInitMinter';
+    queryId: uint64;
+    jettonWallet: c.Address;
+    excesses: c.Address;
+}
+export declare const InternalInitMinter: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        jettonWallet: c.Address;
+        excesses: c.Address;
+    }): InternalInitMinter;
+    fromSlice(s: c.Slice): InternalInitMinter;
+    store(self: InternalInitMinter, b: c.Builder): void;
+    toCell(self: InternalInitMinter): c.Cell;
+};
+/**
+ > struct (0xa68f2242) Register {
+ >     queryId: uint64
+ >     publicViewKey: Point
+ > }
+ */
+export interface Register {
+    readonly $: 'Register';
+    queryId: uint64;
+    publicViewKey: Point;
+}
+export declare const Register: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        publicViewKey: Point;
+    }): Register;
+    fromSlice(s: c.Slice): Register;
+    store(self: Register, b: c.Builder): void;
+    toCell(self: Register): c.Cell;
+};
+/**
+ > struct (0x37c7e6fe) InternalWithdraw {
+ >     queryId: uint64
+ >     from: address
+ >     amount: coins
+ > }
+ */
+export interface InternalWithdraw {
+    readonly $: 'InternalWithdraw';
+    queryId: uint64;
+    from: c.Address;
+    amount: coins;
+}
+export declare const InternalWithdraw: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        from: c.Address;
+        amount: coins;
+    }): InternalWithdraw;
+    fromSlice(s: c.Slice): InternalWithdraw;
+    store(self: InternalWithdraw, b: c.Builder): void;
+    toCell(self: InternalWithdraw): c.Cell;
+};
+/**
+ > struct (0x0fccc477) FlipWalletStatus {
+ >     queryId: uint64
+ >     owner: address
+ > }
+ */
+export interface FlipWalletStatus {
+    readonly $: 'FlipWalletStatus';
+    queryId: uint64;
+    owner: c.Address;
+}
+export declare const FlipWalletStatus: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        owner: c.Address;
+    }): FlipWalletStatus;
+    fromSlice(s: c.Slice): FlipWalletStatus;
+    store(self: FlipWalletStatus, b: c.Builder): void;
+    toCell(self: FlipWalletStatus): c.Cell;
+};
+/**
+ > struct (0x28c6c21a) InternalResetGas {
+ >     queryId: uint64
+ >     excess: address
+ > }
+ */
+export interface InternalResetGas {
+    readonly $: 'InternalResetGas';
+    queryId: uint64;
+    excess: c.Address;
+}
+export declare const InternalResetGas: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        excess: c.Address;
+    }): InternalResetGas;
+    fromSlice(s: c.Slice): InternalResetGas;
+    store(self: InternalResetGas, b: c.Builder): void;
+    toCell(self: InternalResetGas): c.Cell;
+};
+/**
+ > struct (0xde913221) InternalDeposit {
+ >     queryId: uint64
+ >     amount: coins
+ >     commitment: Point
+ >     proof: Cell<Proof>
+ > }
+ */
+export interface InternalDeposit {
+    readonly $: 'InternalDeposit';
+    queryId: uint64;
+    amount: coins;
+    commitment: Point;
+    proof: CellRef<Proof>;
+}
+export declare const InternalDeposit: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        amount: coins;
+        commitment: Point;
+        proof: CellRef<Proof>;
+    }): InternalDeposit;
+    fromSlice(s: c.Slice): InternalDeposit;
+    store(self: InternalDeposit, b: c.Builder): void;
+    toCell(self: InternalDeposit): c.Cell;
+};
+/**
+ > struct (0xdde0f974) InternalRegister {
+ >     queryId: uint64
+ >     publicViewKey: Point
+ > }
+ */
+export interface InternalRegister {
+    readonly $: 'InternalRegister';
+    queryId: uint64;
+    publicViewKey: Point;
+}
+export declare const InternalRegister: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        publicViewKey: Point;
+    }): InternalRegister;
+    fromSlice(s: c.Slice): InternalRegister;
+    store(self: InternalRegister, b: c.Builder): void;
+    toCell(self: InternalRegister): c.Cell;
+};
+/**
+ > struct (0x158bd66b) InternalFlipWalletStatus {
+ >     queryId: uint64
+ >     excess: address
+ > }
+ */
+export interface InternalFlipWalletStatus {
+    readonly $: 'InternalFlipWalletStatus';
+    queryId: uint64;
+    excess: c.Address;
+}
+export declare const InternalFlipWalletStatus: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        excess: c.Address;
+    }): InternalFlipWalletStatus;
+    fromSlice(s: c.Slice): InternalFlipWalletStatus;
+    store(self: InternalFlipWalletStatus, b: c.Builder): void;
+    toCell(self: InternalFlipWalletStatus): c.Cell;
+};
+/**
+ > struct Point {
+ >     x: uint256
+ >     y: uint256
+ > }
+ */
+export interface Point {
+    readonly $: 'Point';
+    x: uint256;
+    y: uint256;
+}
+export declare const Point: {
+    create(args: {
+        x: uint256;
+        y: uint256;
+    }): Point;
+    fromSlice(s: c.Slice): Point;
+    store(self: Point, b: c.Builder): void;
+    toCell(self: Point): c.Cell;
+};
+/**
+ > struct Proof {
+ >     piA: cell
+ >     piB: cell
+ >     piC: cell
+ > }
+ */
+export interface Proof {
+    readonly $: 'Proof';
+    piA: c.Cell;
+    piB: c.Cell;
+    piC: c.Cell;
+}
+export declare const Proof: {
+    create(args: {
+        piA: c.Cell;
+        piB: c.Cell;
+        piC: c.Cell;
+    }): Proof;
+    fromSlice(s: c.Slice): Proof;
+    store(self: Proof, b: c.Builder): void;
+    toCell(self: Proof): 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 Minter implements c.Contract {
+    static Errors: {
+        'Errors.InvalidEitherBit': number;
+        'Errors.InvalidAmount': number;
+        'Errors.AlreadyInitialized': number;
+        'Errors.NotAlreadyInitialized': number;
+        'Errors.NotEnoughGas': number;
+        'Errors.InvalidPoint': number;
+        'Errors.InvalidWorkchain': number;
+        'Errors.WrongSender': number;
+        'Errors.WrongOp': 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): Minter;
+    static createCellOfInternalInitMinter(body: {
+        queryId: uint64;
+        jettonWallet: c.Address;
+        excesses: c.Address;
+    }): c.Cell;
+    static createCellOfJettonTransferNotification(body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        from: c.Address;
+        forwardPayload: RemainingBitsAndRefs;
+    }): c.Cell;
+    static createCellOfRegister(body: {
+        queryId: uint64;
+        publicViewKey: Point;
+    }): c.Cell;
+    static createCellOfInternalWithdraw(body: {
+        queryId: uint64;
+        from: c.Address;
+        amount: coins;
+    }): c.Cell;
+    static createCellOfFlipWalletStatus(body: {
+        queryId: uint64;
+        owner: c.Address;
+    }): c.Cell;
+    static createCellOfInternalResetGas(body: {
+        queryId: uint64;
+        excess: c.Address;
+    }): c.Cell;
+    static createCellOfExcessMessage(body: {
+        queryId: uint64;
+    }): c.Cell;
+    sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInternalInitMinter(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        jettonWallet: c.Address;
+        excesses: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendJettonTransferNotification(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        jettonAmount: coins;
+        from: c.Address;
+        forwardPayload: RemainingBitsAndRefs;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendRegister(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        publicViewKey: Point;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInternalWithdraw(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        from: c.Address;
+        amount: coins;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendFlipWalletStatus(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        owner: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInternalResetGas(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        excess: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendExcessMessage(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    getMinterData(provider: ContractProvider): Promise<MinterRuntimeStorage>;
+    getWalletAddress(provider: ContractProvider, owner: c.Address): Promise<c.Address>;
+    getJettonData(provider: ContractProvider): Promise<[
+        bigint,
+        bigint,
+        any_address,
+        c.Cell,
+        c.Cell
+    ]>;
+}
+export {};