@blockassetlabs/blaze/dist/esm/programs/blockasset-blaze/transaction.js

Blockasset Blaze

import { BN } from '@project-serum/anchor';
import { Keypair, SystemProgram } from '@solana/web3.js';
import { tryGetAccount } from '../../utils/tryGetAccount';
import { withFindOrInitAssociatedTokenAccount } from '../../utils/withFindOrInitAssociatedTokenAccount';
import { getIdentifier } from './accounts';
import { BLAZE_ADDRESS } from './constants';
import { claimPrizeInstruction, closeBlazeInstruction, initBlazeInstruction, initIdentifierInstruction, redeemEntrantsInstruction, resolveBlazeInstruction, updateBlazeInstruction } from './instruction';
import { findBlazeId, findIdentifierId } from './pda';
/**
 * Add init blaze identifier instructions to a transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @returns Transaction, public key for the created blaze identifier
 */
export const withInitBlazeIdentifier = async (transaction, connection, wallet) => {
    const [identifierId] = await findIdentifierId();
    transaction.add(await initIdentifierInstruction(connection, wallet, {
        identifierId: identifierId
    }));
    return [transaction, identifierId];
};
export const withInitBlaze = async (transaction, connection, wallet, params) => {
    const [[identifierId], identifierData] = await Promise.all([
        findIdentifierId(),
        tryGetAccount(() => getIdentifier(connection))
    ]);
    const identifier = (identifierData === null || identifierData === void 0 ? void 0 : identifierData.parsed.count) || new BN(1);
    if (!identifierData) {
        transaction.add(await initIdentifierInstruction(connection, wallet, {
            identifierId: identifierId
        }));
    }
    const [blazeId] = await findBlazeId(identifier);
    const [blazePrizeMintTokenAccount, userPrizeMintTokenAccount] = await Promise.all([
        withFindOrInitAssociatedTokenAccount(transaction, connection, params.prizeMint, blazeId, wallet.publicKey, true),
        withFindOrInitAssociatedTokenAccount(transaction, connection, params.prizeMint, wallet.publicKey, wallet.publicKey)
    ]);
    const entrantsAccountDataSize = 8 + 4 + 4 + 32 * params.maxEntrants;
    const entrantsKeyPair = Keypair.generate();
    const lamports = await connection.getMinimumBalanceForRentExemption(entrantsAccountDataSize, 'confirmed');
    transaction.add(SystemProgram.createAccount({
        fromPubkey: wallet.publicKey,
        newAccountPubkey: entrantsKeyPair.publicKey,
        space: entrantsAccountDataSize,
        lamports,
        programId: BLAZE_ADDRESS
    }), await initBlazeInstruction(connection, wallet, {
        identifierId,
        blazeId,
        projectId: params.projectId,
        projectWallet: params.projectWallet,
        blazePrizeMintTokenAccount,
        userPrizeMintTokenAccount,
        entrants: entrantsKeyPair.publicKey,
        tokenMint: params.tokenMint,
        tokenAccount: params.tokenAccount,
        treasury: params.treasury,
        burnRate: params.burnRate,
        category: params.category,
        prizeMint: params.prizeMint,
        entrantFee: params.entrantFee,
        maxEntrants: params.maxEntrants,
        start: params.start,
        end: params.end,
        maxEntrantsPerWalletRate: params.maxEntrantsPerWalletRate
    }));
    return [transaction, blazeId, entrantsKeyPair];
};
export const withUpdateBlaze = async (transaction, connection, wallet, params) => {
    transaction.add(await updateBlazeInstruction(connection, wallet, {
        blazeId: params.blazeId,
        projectId: params.projectId,
        tokenMint: params.tokenMint,
        tokenAccount: params.tokenAccount,
        treasury: params.treasury,
        burnRate: params.burnRate,
        entrantFee: params.entrantFee,
        start: params.start,
        end: params.end,
        maxEntrantsPerWalletRate: params.maxEntrantsPerWalletRate,
        category: params.category
    }));
    return transaction;
};
export const withCloseBlaze = async (transaction, connection, wallet, params) => {
    const [blazePrizeMintTokenAccount, userPrizeMintTokenAccount] = await Promise.all([
        withFindOrInitAssociatedTokenAccount(transaction, connection, params.prizeMint, params.blazeId, wallet.publicKey, true),
        withFindOrInitAssociatedTokenAccount(transaction, connection, params.prizeMint, wallet.publicKey, wallet.publicKey)
    ]);
    transaction.add(await closeBlazeInstruction(connection, wallet, {
        blazeId: params.blazeId,
        projectId: params.projectId,
        entrants: params.entrants,
        blazePrizeMintTokenAccount,
        userPrizeMintTokenAccount
    }));
    return transaction;
};
export const withRedeemEntrants = async (transaction, connection, wallet, params) => {
    transaction.add(await redeemEntrantsInstruction(connection, wallet, params));
    return transaction;
};
export const withResolveBlaze = async (transaction, connection, wallet, params) => {
    transaction.add(await resolveBlazeInstruction(connection, wallet, {
        blazeId: params.blazeId,
        entrants: params.entrants
    }));
    return transaction;
};
export const withClaimPrize = async (transaction, connection, wallet, params) => {
    const [blazePrizeMintTokenAccount, winnerPrizeMintTokenAccount] = await Promise.all([
        withFindOrInitAssociatedTokenAccount(transaction, connection, params.prizeMint, params.blazeId, wallet.publicKey, true),
        withFindOrInitAssociatedTokenAccount(transaction, connection, params.prizeMint, wallet.publicKey, wallet.publicKey)
    ]);
    transaction.add(await claimPrizeInstruction(connection, wallet, {
        blazeId: params.blazeId,
        blazePrizeMintTokenAccount,
        winnerPrizeMintTokenAccount
    }));
    return transaction;
};
//# sourceMappingURL=transaction.js.map