"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SPLToken = exports.NATIVE_MINT = exports.AccountLayout = exports.MintLayout = void 0;
const web3_js_1 = require("@solana/web3.js");
const System_1 = require("./System");
const _1 = require(".");
const BaseProgram_1 = require("./BaseProgram");
const buffer_layout_1 = __importDefault(require("buffer-layout"));
const encoding_1 = require("./util/encoding");
exports.MintLayout = buffer_layout_1.default.struct([
    buffer_layout_1.default.u32('mintAuthorityOption'),
    encoding_1.publicKey('mintAuthority'),
    encoding_1.uint64('supply'),
    buffer_layout_1.default.u8('decimals'),
    buffer_layout_1.default.u8('isInitialized'),
    buffer_layout_1.default.u32('freezeAuthorityOption'),
    encoding_1.publicKey('freezeAuthority'),
]);
exports.AccountLayout = buffer_layout_1.default.struct([
    encoding_1.publicKey('mint'),
    encoding_1.publicKey('owner'),
    encoding_1.uint64('amount'),
    buffer_layout_1.default.u32('delegateOption'),
    encoding_1.publicKey('delegate'),
    buffer_layout_1.default.u8('state'),
    buffer_layout_1.default.u32('isNativeOption'),
    encoding_1.uint64('isNative'),
    encoding_1.uint64('delegatedAmount'),
    buffer_layout_1.default.u32('closeAuthorityOption'),
    encoding_1.publicKey('closeAuthority'),
]);
const AuthorityTypeCodes = {
    MintTokens: 0,
    FreezeAccount: 1,
    AccountOwner: 2,
    CloseAccount: 3,
};
const MultisigLayout = buffer_layout_1.default.struct([
    buffer_layout_1.default.u8('m'),
    buffer_layout_1.default.u8('n'),
    buffer_layout_1.default.u8('is_initialized'),
    encoding_1.publicKey('signer1'),
    encoding_1.publicKey('signer2'),
    encoding_1.publicKey('signer3'),
    encoding_1.publicKey('signer4'),
    encoding_1.publicKey('signer5'),
    encoding_1.publicKey('signer6'),
    encoding_1.publicKey('signer7'),
    encoding_1.publicKey('signer8'),
    encoding_1.publicKey('signer9'),
    encoding_1.publicKey('signer10'),
    encoding_1.publicKey('signer11'),
]);
// The address of the special mint for wrapped native token.
exports.NATIVE_MINT = new _1.PublicKey('So11111111111111111111111111111111111111112');
class SPLToken extends BaseProgram_1.BaseProgram {
    constructor(wallet, programID = SPLToken.programID) {
        super(wallet, programID);
        this.sys = new System_1.System(this.wallet);
    }
    /**
     * Retrieve mint information
     *
     * @param token Public key of the token
     */
    async mintInfo(token) {
        const info = await this.wallet.conn.getAccountInfo(token);
        if (info === null) {
            throw new Error('Failed to find mint account');
        }
        if (!info.owner.equals(this.programID)) {
            throw new Error(`Invalid mint owner: ${JSON.stringify(info.owner)}`);
        }
        if (info.data.length != exports.MintLayout.span) {
            throw new Error(`Invalid mint size`);
        }
        const data = Buffer.from(info.data);
        const mintInfo = exports.MintLayout.decode(data);
        if (mintInfo.mintAuthorityOption === 0) {
            mintInfo.mintAuthority = null;
        }
        else {
            mintInfo.mintAuthority = new _1.PublicKey(mintInfo.mintAuthority);
        }
        mintInfo.supply = mintInfo.supply.readBigUInt64LE();
        mintInfo.isInitialized = mintInfo.isInitialized != 0;
        if (mintInfo.freezeAuthorityOption === 0) {
            mintInfo.freezeAuthority = null;
        }
        else {
            mintInfo.freezeAuthority = new _1.PublicKey(mintInfo.freezeAuthority);
        }
        return mintInfo;
    }
    /**
     * Retrieve account information
     *
     * @param account Public key of the account
     */
    async accountInfo(account) {
        const info = await this.conn.getAccountInfo(account);
        if (info === null) {
            throw new Error('Failed to find account');
        }
        if (!info.owner.equals(this.programID)) {
            throw new Error(`Invalid account owner`);
        }
        if (info.data.length != exports.AccountLayout.span) {
            throw new Error(`Invalid account size`);
        }
        const data = Buffer.from(info.data);
        const accountInfo = exports.AccountLayout.decode(data);
        accountInfo.mint = new _1.PublicKey(accountInfo.mint);
        accountInfo.owner = new _1.PublicKey(accountInfo.owner);
        accountInfo.amount = encoding_1.u64FromBuffer(accountInfo.amount);
        if (accountInfo.delegateOption === 0) {
            accountInfo.delegate = null;
            accountInfo.delegatedAmount = BigInt(0);
        }
        else {
            accountInfo.delegate = new _1.PublicKey(accountInfo.delegate);
            accountInfo.delegatedAmount = encoding_1.u64FromBuffer(accountInfo.delegatedAmount);
        }
        accountInfo.isInitialized = accountInfo.state !== 0;
        accountInfo.isFrozen = accountInfo.state === 2;
        if (accountInfo.isNativeOption === 1) {
            accountInfo.rentExemptReserve = encoding_1.u64FromBuffer(accountInfo.isNative);
            accountInfo.isNative = true;
        }
        else {
            accountInfo.rentExemptReserve = null;
            accountInfo.isNative = false;
        }
        if (accountInfo.closeAuthorityOption === 0) {
            accountInfo.closeAuthority = null;
        }
        else {
            accountInfo.closeAuthority = new _1.PublicKey(accountInfo.closeAuthority);
        }
        return accountInfo;
    }
    /**
     * Retrieve Multisig information
     *
     * @param multisig Public key of the account
     */
    async multisigInfo(multisig) {
        const info = await this.conn.getAccountInfo(multisig);
        if (info === null) {
            throw new Error('Failed to find multisig');
        }
        if (!info.owner.equals(this.programID)) {
            throw new Error(`Invalid multisig owner`);
        }
        if (info.data.length != MultisigLayout.span) {
            throw new Error(`Invalid multisig size`);
        }
        const data = Buffer.from(info.data);
        const multisigInfo = MultisigLayout.decode(data);
        multisigInfo.signer1 = new _1.PublicKey(multisigInfo.signer1);
        multisigInfo.signer2 = new _1.PublicKey(multisigInfo.signer2);
        multisigInfo.signer3 = new _1.PublicKey(multisigInfo.signer3);
        multisigInfo.signer4 = new _1.PublicKey(multisigInfo.signer4);
        multisigInfo.signer5 = new _1.PublicKey(multisigInfo.signer5);
        multisigInfo.signer6 = new _1.PublicKey(multisigInfo.signer6);
        multisigInfo.signer7 = new _1.PublicKey(multisigInfo.signer7);
        multisigInfo.signer8 = new _1.PublicKey(multisigInfo.signer8);
        multisigInfo.signer9 = new _1.PublicKey(multisigInfo.signer9);
        multisigInfo.signer10 = new _1.PublicKey(multisigInfo.signer10);
        multisigInfo.signer11 = new _1.PublicKey(multisigInfo.signer11);
        return multisigInfo;
    }
    /**
     * Creates a new token with zero supply
     *
     * @param mintAuthority Account or multisig that will control minting
     * @param freezeAuthority Optional account or multisig that can freeze token accounts
     * @param decimals Location of the decimal place
     * @return Token object for the newly minted token
     */
    async initializeMint(params) {
        const account = params.account || new _1.Account();
        await this.sendTx([
            await this.sys.createRentFreeAccountInstruction({
                newPubicKey: account.publicKey,
                programID: this.programID,
                space: exports.MintLayout.span
            }),
            this.initMintInstruction({
                token: account.publicKey,
                ...params,
            })
        ], [this.account, account]);
        return account;
    }
    initMintInstruction(params) {
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            buffer_layout_1.default.u8('decimals'),
            encoding_1.publicKey('mintAuthority'),
            buffer_layout_1.default.u8('option'),
            encoding_1.publicKey('freezeAuthority'),
        ]);
        const { token, decimals, mintAuthority, freezeAuthority } = params;
        return this.instructionEncode(layout, {
            instruction: 0,
            decimals,
            mintAuthority: mintAuthority.toBuffer(),
            option: !freezeAuthority ? 0 : 1,
            freezeAuthority: (freezeAuthority || new _1.PublicKey(0)).toBuffer(),
        }, [
            { write: token },
            web3_js_1.SYSVAR_RENT_PUBKEY,
        ]);
    }
    /**
     * Creates an account to hold token balance
     *
     * This account may then be used as a `transfer()` or `approve()` destination
     *
     * @param owner User account that will own the new account
     * @return Public key of the new empty account
     */
    async initializeAccount(params) {
        const account = params.account || new _1.Account();
        await this.sendTx([
            await this.sys.createRentFreeAccountInstruction({
                newPubicKey: account.publicKey,
                programID: this.programID,
                space: exports.AccountLayout.span
            }),
            this.initAccountInstruction({
                account: account.publicKey,
                token: params.token,
                owner: params.owner,
            })
        ], [this.account, account]);
        return account;
    }
    initAccountInstruction(params) {
        const layout = buffer_layout_1.default.struct([buffer_layout_1.default.u8('instruction')]);
        return this.instructionEncode(layout, { instruction: 1 }, [
            { write: params.account },
            params.token,
            params.owner,
            web3_js_1.SYSVAR_RENT_PUBKEY,
        ]);
    }
    /**
     * Create and initialize a new account on the special native token mint.
     *
     * In order to be wrapped, the account must have a balance of native tokens
     * when it is initialized with the token program.
     *
     * This function sends lamports to the new account before initializing it.
     *
     * @param onwer The owner of the new token account
     * @param amount The amount of lamports to wrap
     * @return {Promise<PublicKey>} The new token account
     */
    async initializeWrappedNativeAccount(params) {
        const account = params.account || new _1.Account();
        await this.sendTx([
            await this.sys.createRentFreeAccountInstruction({
                newPubicKey: account.publicKey,
                programID: this.programID,
                space: exports.AccountLayout.span
            }),
            this.sys.createTransferInstruction({
                to: account.publicKey,
                amount: params.amount,
            }),
            this.initAccountInstruction({
                account: account.publicKey,
                token: exports.NATIVE_MINT,
                owner: params.owner,
            })
        ], [this.account, account]);
        return account;
    }
    /**
     * Mint new tokens
     *
     * @param token To mint token
     * @param amount Amount to mint
     * @param to Public key of the account to mint to
     * @param authority Minting authority
     * @param multiSigners Signing accounts if `authority` is a multiSig
     */
    async mintTo(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : (multiSigners || []);
        await this.sendTx([this.mintToInstruction(params)], [this.account, ...signers]);
    }
    mintToInstruction(params) {
        const { token, amount, to, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            encoding_1.uint64('amount'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 7,
            amount: encoding_1.u64LEBuffer(amount),
        }, [
            { write: token },
            { write: to },
            authority,
            multiSigners || [],
        ]);
    }
    /**
     * Construct an Approve instruction
     *
     * @param amount Maximum number of tokens the delegate may transfer
     * @param account Public key of the account
     * @param delegate Account authorized to perform a transfer of tokens from the source account
     * @param authority Owner of the source account
     * @param multiSigners Signing accounts if `owner` is a multiSig
     */
    async approve(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.approveInstruction(params)], [this.account, ...signers]);
    }
    approveInstruction(params) {
        const { amount, account, delegate, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            encoding_1.uint64('amount'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 4,
            amount: encoding_1.u64LEBuffer(amount),
        }, [
            { write: account },
            delegate,
            authority,
            multiSigners
        ]);
    }
    /**
     * Remove approval for the transfer of any remaining tokens
     *
     * @param account Public key of the account
     * @param authority Owner of the source account
     * @param multiSigners Signing accounts if `owner` is a multiSig
     */
    async revoke(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.revokeInstruction(params)], [this.account, ...signers]);
    }
    revokeInstruction(params) {
        const { account, authority, multiSigners } = params;
        const layout = buffer_layout_1.default.struct([buffer_layout_1.default.u8('instruction')]);
        return this.instructionEncode(layout, { instruction: 5 }, [
            { write: account },
            authority,
            multiSigners
        ]);
    }
    /**
     * Burn tokens
     *
     * @param token The token pubkey
     * @param from  Burn from account
     * @param amount Amount to burn
     * @param authority Account owner
     * @param multiSigners Signing accounts if `owner` is a multiSig
     */
    async burn(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.burnInstruction(params)], [this.account, ...signers]);
    }
    burnInstruction(params) {
        const { token, from, amount, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            encoding_1.uint64('amount'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 8,
            amount: encoding_1.u64LEBuffer(amount),
        }, [
            { write: from },
            { write: token },
            authority,
            multiSigners
        ]);
    }
    /**
     * Transfer tokens to another account
     *
     * @param from Source account
     * @param to Destination account
     * @param amount Number of tokens to transfer
     * @param authority Owner of the source account
     * @param multiSigners Signing accounts if `owner` is a multiSig
     */
    async transfer(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.transferInstruction(params)], [this.account, ...signers]);
    }
    transferInstruction(params) {
        const { from, to, amount, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            encoding_1.uint64('amount'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 3,
            amount: encoding_1.u64LEBuffer(amount),
        }, [
            { write: from },
            { write: to },
            authority,
            multiSigners
        ]);
    }
    /**
     * Assign a new authority to the account
     *
     * @param account Public key of the account
     * @param newAuthority New authority of the account
     * @param authorityType Type of authority to set
     * @param currentAuthority Current authority of the account
     * @param multiSigners Signing accounts if `currentAuthority` is a multiSig
     */
    async setAuthority(params) {
        const { currentAuthority, multiSigners } = params;
        const signers = currentAuthority.constructor == _1.Account ? [currentAuthority] : multiSigners;
        await this.sendTx([this.setAuthorityInstruction(params)], [this.account, ...signers]);
    }
    setAuthorityInstruction(params) {
        const { account, newAuthority, authorityType, currentAuthority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            buffer_layout_1.default.u8('authorityType'),
            buffer_layout_1.default.u8('option'),
            encoding_1.publicKey('newAuthority'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 6,
            authorityType: AuthorityTypeCodes[authorityType],
            option: newAuthority === null ? 0 : 1,
            newAuthority: (newAuthority || new _1.PublicKey('')).toBuffer(),
        }, [
            { write: account },
            currentAuthority,
            multiSigners
        ]);
    }
    /**
     * Close account
     *
     * @param account Account to close
     * @param dest Account to receive the remaining balance of the closed account
     * @param authority Authority which is allowed to close the account
     * @param multiSigners Signing accounts if `authority` is a multiSig
     */
    async closeAccount(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.closeAccountInstruction(params)], [this.account, ...signers]);
    }
    closeAccountInstruction(params) {
        const { account, dest, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 9,
        }, [
            { write: account },
            { write: dest },
            authority,
            multiSigners
        ]);
    }
    /**
     * Freeze account
     *
     * @param token The token public key
     * @param account Account to freeze
     * @param authority The mint freeze authority
     * @param multiSigners Signing accounts if `authority` is a multiSig
     */
    async freezeAccount(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.freezeAccountInstruction(params)], [this.account, ...signers]);
    }
    freezeAccountInstruction(params) {
        const { token, account, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 10,
        }, [
            { write: account },
            token,
            authority,
            multiSigners
        ]);
    }
    /**
     * Thaw account
     *
     * @param account Account to thaw
     * @param authority The mint freeze authority
     * @param multiSigners Signing accounts if `authority` is a multiSig
     */
    async thawAccount(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.thawAccountInstruction(params)], [this.account, ...signers]);
    }
    thawAccountInstruction(params) {
        const { token, account, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 11,
        }, [
            { write: account },
            token,
            authority,
            multiSigners
        ]);
    }
    /**
     * Transfer tokens to another account
     *
     * @param from Source account
     * @param to Destination account
     * @param token The token public key
     * @param amount Number of tokens to transfer
     * @param decimals Number of decimals in transfer amount
     * @param authority Owner of the source account
     * @param multiSigners Signing accounts if `owner` is a multiSig
     */
    async transfer2(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.transfer2Instruction(params)], [this.account, ...signers]);
    }
    transfer2Instruction(params) {
        const { from, to, token, amount, decimals, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            encoding_1.uint64('amount'),
            buffer_layout_1.default.u8('decimals'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 12,
            amount: encoding_1.u64LEBuffer(amount),
            decimals,
        }, [
            { write: from },
            token,
            { write: to },
            authority,
            multiSigners
        ]);
    }
    /**
     * Construct an Approve instruction
     *
     * @param token The token public key
     * @param amount Maximum number of tokens the delegate may transfer
     * @param account Public key of the account
     * @param decimals Number of decimals in approve amount
     * @param delegate Account authorized to perform a transfer of tokens from the source account
     * @param authority Owner of the source account
     * @param multiSigners Signing accounts if `owner` is a multiSig
     */
    async approve2(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.approve2Instruction(params)], [this.account, ...signers]);
    }
    approve2Instruction(params) {
        const { token, amount, account, decimals, delegate, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            encoding_1.uint64('amount'),
            buffer_layout_1.default.u8('decimals'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 13,
            amount: encoding_1.u64LEBuffer(amount),
            decimals,
        }, [
            { write: account },
            token,
            delegate,
            authority,
            multiSigners
        ]);
    }
    /**
     * Mint new tokens
     *
     * @param token To mint token
     * @param amount Amount to mint
     * @param decimals Number of decimals in amount to mint
     * @param to Public key of the account to mint to
     * @param authority Minting authority
     * @param multiSigners Signing accounts if `authority` is a multiSig
     */
    async mintTo2(params) {
        const { authority, multiSigners } = params;
        const signers = authority.constructor == _1.Account ? [authority] : multiSigners;
        await this.sendTx([this.mintTo2Instruction(params)], [this.account, ...signers]);
    }
    mintTo2Instruction(params) {
        const { token, amount, decimals, to, authority, multiSigners, } = params;
        const layout = buffer_layout_1.default.struct([
            buffer_layout_1.default.u8('instruction'),
            encoding_1.uint64('amount'),
            buffer_layout_1.default.u8('decimals'),
        ]);
        return this.instructionEncode(layout, {
            instruction: 14,
            amount: encoding_1.u64LEBuffer(amount),
            decimals,
        }, [
            { write: token },
            { write: to },
            authority,
            multiSigners
        ]);
    }
}
exports.SPLToken = SPLToken;
SPLToken.programID = new _1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");