@blockassetlabs/minter/dist/esm/programs/blockasset-minter/accounts.js

Blockasset Minter

import { AnchorProvider, BorshAccountsCoder, Program, utils, } from "@project-serum/anchor";
import { SignerWallet } from "@saberhq/solana-contrib";
import { Keypair, PublicKey } from "@solana/web3.js";
import { MINTER_ADDRESS, MINTER_DISCRIMINATOR, MINTER_IDL, MINTER_PROJECT_ID_OFFSET, REDEEMED_MINTS_ACCOUNT_NAME, } from "./constants";
const getProgram = (connection, commitment = "processed") => {
    const provider = new AnchorProvider(connection, new SignerWallet(Keypair.generate()), {
        commitment,
    });
    return new Program(MINTER_IDL, MINTER_ADDRESS, provider);
};
export const getMinter = async (connection, minterId, commitment) => {
    const program = getProgram(connection, commitment);
    const parsed = await program.account.minter.fetch(minterId);
    return {
        parsed,
        pubkey: minterId,
    };
};
export const getMinters = async (connection, minterIds, commitment) => {
    const program = getProgram(connection, commitment);
    const minters = (await program.account.minter.fetchMultiple(minterIds));
    return minters.map((tm, i) => ({
        parsed: tm,
        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
        pubkey: minterIds[i],
    }));
};
export const getAllMinters = async (connection, commitment) => {
    if (!connection)
        return [];
    const programAccounts = await connection.getProgramAccounts(MINTER_ADDRESS, {
        filters: [
            {
                memcmp: {
                    offset: 0,
                    bytes: utils.bytes.bs58.encode(BorshAccountsCoder.accountDiscriminator(MINTER_DISCRIMINATOR)),
                },
            },
        ],
        commitment,
    });
    const minterDatas = [];
    const coder = new BorshAccountsCoder(MINTER_IDL);
    programAccounts.forEach((account) => {
        try {
            const minterData = coder.decode(MINTER_DISCRIMINATOR, account.account.data);
            if (minterData) {
                minterDatas.push({
                    ...account,
                    parsed: minterData,
                });
            }
            // eslint-disable-next-line no-empty
        }
        catch (e) { }
    });
    return minterDatas.sort((a, b) => a.pubkey.toBase58().localeCompare(b.pubkey.toBase58()));
};
export const getMintersByProjectId = async (connection, projectId, commitment) => {
    if (!connection)
        return [];
    const programAccounts = await connection.getProgramAccounts(MINTER_ADDRESS, {
        filters: [
            {
                memcmp: {
                    offset: 0,
                    bytes: utils.bytes.bs58.encode(BorshAccountsCoder.accountDiscriminator(MINTER_DISCRIMINATOR)),
                },
            },
            {
                memcmp: {
                    offset: MINTER_PROJECT_ID_OFFSET,
                    bytes: projectId.toBase58(),
                },
            },
        ],
        commitment,
    });
    const minterDatas = [];
    const coder = new BorshAccountsCoder(MINTER_IDL);
    programAccounts.forEach((account) => {
        try {
            const minterData = coder.decode(MINTER_DISCRIMINATOR, account.account.data);
            if (minterData) {
                minterDatas.push({
                    ...account,
                    parsed: minterData,
                });
            }
            // eslint-disable-next-line no-empty
        }
        catch (e) { }
    });
    return minterDatas.sort((a, b) => a.pubkey.toBase58().localeCompare(b.pubkey.toBase58()));
};
export const getRedeemedMints = async (connection, redeemedMintsId, commitment) => {
    const program = getProgram(connection, commitment);
    const accountInfo = await program.account.redeemedMints.getAccountInfo(redeemedMintsId);
    if (!accountInfo)
        return null;
    const coder = new BorshAccountsCoder(MINTER_IDL);
    try {
        const redeemedMintsDataRaw = coder.decodeUnchecked(REDEEMED_MINTS_ACCOUNT_NAME, accountInfo.data);
        if (!redeemedMintsDataRaw)
            return null;
        const mints = [];
        const mintsFieldData = accountInfo.data.subarray(8 + 4 + 32);
        for (let i = 0; i < redeemedMintsDataRaw.total; i++) {
            mints.push(new PublicKey(mintsFieldData.slice(i * 32, (i + 1) * 32)));
        }
        return {
            pubkey: redeemedMintsId,
            parsed: { ...redeemedMintsDataRaw, mints },
        };
    }
    catch (e) {
        console.error(e);
        return null;
    }
};
//# sourceMappingURL=accounts.js.map