@metoncash/sdk-v1 0.1.0

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

@@ -0,0 +1,542 @@
+import * as c from '@ton/core';
+import { ContractProvider, Sender, SendMode } from '@ton/core';
+export type CellRef<T> = {
+    ref: T;
+};
+type coins = bigint;
+type uint32 = bigint;
+type uint64 = bigint;
+type uint256 = bigint;
+/**
+ > struct AccountRuntimeStorage {
+ >     locked: bool
+ >     minter: address
+ >     owner: address
+ >     seqNo: uint32
+ >     publicViewKey: Point
+ >     commitment: Point
+ > }
+ */
+export interface AccountRuntimeStorage {
+    readonly $: 'AccountRuntimeStorage';
+    locked: boolean;
+    minter: c.Address;
+    owner: c.Address;
+    seqNo: uint32;
+    publicViewKey: Point;
+    commitment: Point;
+}
+export declare const AccountRuntimeStorage: {
+    create(args: {
+        locked: boolean;
+        minter: c.Address;
+        owner: c.Address;
+        seqNo: uint32;
+        publicViewKey: Point;
+        commitment: Point;
+    }): AccountRuntimeStorage;
+    fromSlice(s: c.Slice): AccountRuntimeStorage;
+    store(self: AccountRuntimeStorage, b: c.Builder): void;
+    toCell(self: AccountRuntimeStorage): c.Cell;
+};
+/**
+ > struct AccountStorage {
+ >     locked: bool
+ >     minter: address
+ >     owner: address
+ >     seqNo: uint32
+ >     publicViewKey: Cell<Point>
+ >     commitment: Cell<Point>
+ > }
+ */
+export interface AccountStorage {
+    readonly $: 'AccountStorage';
+    locked: boolean;
+    minter: c.Address;
+    owner: c.Address;
+    seqNo: uint32;
+    publicViewKey: CellRef<Point>;
+    commitment: CellRef<Point>;
+}
+export declare const AccountStorage: {
+    create(args: {
+        locked?: boolean;
+        minter: c.Address;
+        owner: c.Address;
+        seqNo?: uint32;
+        publicViewKey: CellRef<Point>;
+        commitment: CellRef<Point>;
+    }): AccountStorage;
+    fromSlice(s: c.Slice): AccountStorage;
+    store(self: AccountStorage, b: c.Builder): void;
+    toCell(self: AccountStorage): c.Cell;
+};
+/**
+ > struct TransferAdditionalData {
+ >     ephemeral: Point
+ >     encAmount: uint256
+ >     encBlind: Cell<uint256>
+ > }
+ */
+export interface TransferAdditionalData {
+    readonly $: 'TransferAdditionalData';
+    ephemeral: Point;
+    encAmount: uint256;
+    encBlind: CellRef<uint256>;
+}
+export declare const TransferAdditionalData: {
+    create(args: {
+        ephemeral: Point;
+        encAmount: uint256;
+        encBlind: CellRef<uint256>;
+    }): TransferAdditionalData;
+    fromSlice(s: c.Slice): TransferAdditionalData;
+    store(self: TransferAdditionalData, b: c.Builder): void;
+    toCell(self: TransferAdditionalData): c.Cell;
+};
+/**
+ > struct (0x886055ac) InitTransfer {
+ >     queryId: uint64
+ >     to: address
+ >     receiverViewKey: Point
+ >     newCommitment: Cell<Point>
+ >     amountCommit: Cell<Point>
+ >     proof: Cell<Proof>
+ >     ad: Cell<TransferAdditionalData>
+ > }
+ */
+export interface InitTransfer {
+    readonly $: 'InitTransfer';
+    queryId: uint64;
+    to: c.Address;
+    receiverViewKey: Point;
+    newCommitment: CellRef<Point>;
+    amountCommit: CellRef<Point>;
+    proof: CellRef<Proof>;
+    ad: CellRef<TransferAdditionalData>;
+}
+export declare const InitTransfer: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        to: c.Address;
+        receiverViewKey: Point;
+        newCommitment: CellRef<Point>;
+        amountCommit: CellRef<Point>;
+        proof: CellRef<Proof>;
+        ad: CellRef<TransferAdditionalData>;
+    }): InitTransfer;
+    fromSlice(s: c.Slice): InitTransfer;
+    store(self: InitTransfer, b: c.Builder): void;
+    toCell(self: InitTransfer): c.Cell;
+};
+/**
+ > struct InternalTransferAdditionalData {
+ >     ephemeral: Point
+ >     encBlind: uint256
+ > }
+ */
+export interface InternalTransferAdditionalData {
+    readonly $: 'InternalTransferAdditionalData';
+    ephemeral: Point;
+    encBlind: uint256;
+}
+export declare const InternalTransferAdditionalData: {
+    create(args: {
+        ephemeral: Point;
+        encBlind: uint256;
+    }): InternalTransferAdditionalData;
+    fromSlice(s: c.Slice): InternalTransferAdditionalData;
+    store(self: InternalTransferAdditionalData, b: c.Builder): void;
+    toCell(self: InternalTransferAdditionalData): c.Cell;
+};
+/**
+ > struct (0xc22d1aa0) InternalTransfer {
+ >     queryId: uint64
+ >     from: address
+ >     receiverViewKey: Point
+ >     encAmount: Cell<uint256>
+ >     amountCommit: Cell<Point>
+ >     oldStorageCommitment: Cell<Point>
+ >     ad: Cell<InternalTransferAdditionalData>
+ > }
+ */
+export interface InternalTransfer {
+    readonly $: 'InternalTransfer';
+    queryId: uint64;
+    from: c.Address;
+    receiverViewKey: Point;
+    encAmount: CellRef<uint256>;
+    amountCommit: CellRef<Point>;
+    oldStorageCommitment: CellRef<Point>;
+    ad: CellRef<InternalTransferAdditionalData>;
+}
+export declare const InternalTransfer: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        from: c.Address;
+        receiverViewKey: Point;
+        encAmount: CellRef<uint256>;
+        amountCommit: CellRef<Point>;
+        oldStorageCommitment: CellRef<Point>;
+        ad: CellRef<InternalTransferAdditionalData>;
+    }): InternalTransfer;
+    fromSlice(s: c.Slice): InternalTransfer;
+    store(self: InternalTransfer, b: c.Builder): void;
+    toCell(self: InternalTransfer): c.Cell;
+};
+/**
+ > struct (0x5c4dfe3b) TransferCallback {
+ >     queryId: uint64
+ >     from: address
+ > }
+ */
+export interface TransferCallback {
+    readonly $: 'TransferCallback';
+    queryId: uint64;
+    from: c.Address;
+}
+export declare const TransferCallback: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        from: c.Address;
+    }): TransferCallback;
+    fromSlice(s: c.Slice): TransferCallback;
+    store(self: TransferCallback, b: c.Builder): void;
+    toCell(self: TransferCallback): 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 (0xa71f12ae) InitWithdraw {
+ >     queryId: uint64
+ >     amount: coins
+ >     newCommitment: Cell<Point>
+ >     proof: Cell<Proof>
+ > }
+ */
+export interface InitWithdraw {
+    readonly $: 'InitWithdraw';
+    queryId: uint64;
+    amount: coins;
+    newCommitment: CellRef<Point>;
+    proof: CellRef<Proof>;
+}
+export declare const InitWithdraw: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        amount: coins;
+        newCommitment: CellRef<Point>;
+        proof: CellRef<Proof>;
+    }): InitWithdraw;
+    fromSlice(s: c.Slice): InitWithdraw;
+    store(self: InitWithdraw, b: c.Builder): void;
+    toCell(self: InitWithdraw): 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) InternalFlipAccountStatus {
+ >     queryId: uint64
+ >     excess: address
+ > }
+ */
+export interface InternalFlipAccountStatus {
+    readonly $: 'InternalFlipAccountStatus';
+    queryId: uint64;
+    excess: c.Address;
+}
+export declare const InternalFlipAccountStatus: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        excess: c.Address;
+    }): InternalFlipAccountStatus;
+    fromSlice(s: c.Slice): InternalFlipAccountStatus;
+    store(self: InternalFlipAccountStatus, b: c.Builder): void;
+    toCell(self: InternalFlipAccountStatus): 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;
+};
+/**
+ > 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 (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 (0x4882c87b) TransferSuccessfulLog {
+ >     queryId: uint64
+ >     from: address
+ >     data: cell
+ > }
+ */
+export interface TransferSuccessfulLog {
+    readonly $: 'TransferSuccessfulLog';
+    queryId: uint64;
+    from: c.Address;
+    data: c.Cell;
+}
+export declare const TransferSuccessfulLog: {
+    PREFIX: number;
+    create(args: {
+        queryId: uint64;
+        from: c.Address;
+        data: c.Cell;
+    }): TransferSuccessfulLog;
+    fromSlice(s: c.Slice): TransferSuccessfulLog;
+    store(self: TransferSuccessfulLog, b: c.Builder): void;
+    toCell(self: TransferSuccessfulLog): 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 Account implements c.Contract {
+    static Errors: {
+        'DepositErrors.InvalidInputs': number;
+        'TransferErrors.InvalidInputs': number;
+        'WithdrawErrors.InvalidInputs': number;
+        'TransferErrors.IndexOutOfRange': number;
+        'Errors.InvalidProof': number;
+        'Errors.InvalidAmount': number;
+        'Errors.AlreadyInitialized': number;
+        'Errors.NotAlreadyInitialized': number;
+        'Errors.NotEnoughGas': number;
+        'Errors.InvalidPoint': number;
+        'Errors.InvalidWorkchain': number;
+        'Errors.WrongSender': number;
+        'Errors.PositionLocked': 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): Account;
+    static createCellOfInternalDeposit(body: {
+        queryId: uint64;
+        amount: coins;
+        commitment: Point;
+        proof: CellRef<Proof>;
+    }): c.Cell;
+    static createCellOfInitTransfer(body: {
+        queryId: uint64;
+        to: c.Address;
+        receiverViewKey: Point;
+        newCommitment: CellRef<Point>;
+        amountCommit: CellRef<Point>;
+        proof: CellRef<Proof>;
+        ad: CellRef<TransferAdditionalData>;
+    }): c.Cell;
+    static createCellOfInternalTransfer(body: {
+        queryId: uint64;
+        from: c.Address;
+        receiverViewKey: Point;
+        encAmount: CellRef<uint256>;
+        amountCommit: CellRef<Point>;
+        oldStorageCommitment: CellRef<Point>;
+        ad: CellRef<InternalTransferAdditionalData>;
+    }): c.Cell;
+    static createCellOfTransferCallback(body: {
+        queryId: uint64;
+        from: c.Address;
+    }): c.Cell;
+    static createCellOfInitWithdraw(body: {
+        queryId: uint64;
+        amount: coins;
+        newCommitment: CellRef<Point>;
+        proof: CellRef<Proof>;
+    }): c.Cell;
+    static createCellOfInternalRegister(body: {
+        queryId: uint64;
+        publicViewKey: Point;
+    }): c.Cell;
+    static createCellOfInternalFlipAccountStatus(body: {
+        queryId: uint64;
+        excess: c.Address;
+    }): c.Cell;
+    sendDeploy(provider: ContractProvider, via: Sender, msgValue: coins, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInternalDeposit(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        amount: coins;
+        commitment: Point;
+        proof: CellRef<Proof>;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInitTransfer(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        to: c.Address;
+        receiverViewKey: Point;
+        newCommitment: CellRef<Point>;
+        amountCommit: CellRef<Point>;
+        proof: CellRef<Proof>;
+        ad: CellRef<TransferAdditionalData>;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInternalTransfer(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        from: c.Address;
+        receiverViewKey: Point;
+        encAmount: CellRef<uint256>;
+        amountCommit: CellRef<Point>;
+        oldStorageCommitment: CellRef<Point>;
+        ad: CellRef<InternalTransferAdditionalData>;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendTransferCallback(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        from: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInitWithdraw(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        amount: coins;
+        newCommitment: CellRef<Point>;
+        proof: CellRef<Proof>;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInternalRegister(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        publicViewKey: Point;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    sendInternalFlipAccountStatus(provider: ContractProvider, via: Sender, msgValue: coins, body: {
+        queryId: uint64;
+        excess: c.Address;
+    }, extraOptions?: ExtraSendOptions): Promise<void>;
+    getAccountData(provider: ContractProvider): Promise<AccountRuntimeStorage>;
+}
+export {};