@bagsfm/bags-sdk/dist/services/state.js

TypeScript SDK for Bags

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.StateService = void 0;
const web3_js_1 = require("@solana/web3.js");
const bags_client_1 = require("../api/bags-client");
const create_program_1 = require("../utils/create-program");
class StateService {
    constructor(apiKey, connection, commitment = 'processed') {
        this.bagsApiClient = new bags_client_1.BagsApiClient(apiKey);
        this.dbcProgram = (0, create_program_1.createDbcProgram)(connection, commitment).program;
        this.dammV2Program = (0, create_program_1.createDammV2Program)(connection, commitment).program;
        this.bagsMeteoraFeeClaimer = (0, create_program_1.createBagsMeteoraFeeClaimerProgram)(connection, commitment).program;
        this.bagsFeeShareV2 = (0, create_program_1.createBagsFeeShareV2Program)(connection, commitment).program;
        this.bagsFeeShareV2Coder = (0, create_program_1.createBagsFeeShareV2Coder)();
        this.connection = connection;
        this.commitment = commitment;
    }
    getBagsApiClient() {
        return this.bagsApiClient;
    }
    getDbcProgram() {
        return this.dbcProgram;
    }
    getDammV2Program() {
        return this.dammV2Program;
    }
    getBagsMeteoraFeeClaimerProgram() {
        return this.bagsMeteoraFeeClaimer;
    }
    getBagsFeeShareV2Program() {
        return this.bagsFeeShareV2;
    }
    getConnection() {
        return this.connection;
    }
    getCommitment() {
        return this.commitment;
    }
    async getTokenLifetimeFees(tokenMint) {
        const lifeTimeFees = await this.bagsApiClient.get('/token-launch/lifetime-fees', {
            params: {
                tokenMint: tokenMint.toBase58(),
            },
        });
        return parseInt(lifeTimeFees);
    }
    async getTokenCreators(tokenMint) {
        const creators = await this.bagsApiClient.get('/token-launch/creator/v3', {
            params: {
                tokenMint: tokenMint.toBase58(),
            },
        });
        return creators;
    }
    async getTopTokensByLifetimeFees() {
        const response = await this.bagsApiClient.get('/token-launch/top-tokens/lifetime-fees');
        return response;
    }
    async getLaunchWalletForTwitterUsername(twitterUsername) {
        const response = await this.bagsApiClient.get('/token-launch/fee-share/wallet/v2', {
            params: {
                username: twitterUsername,
                provider: 'twitter',
            },
        });
        return new web3_js_1.PublicKey(response.wallet);
    }
    async getPoolConfigKeysByFeeClaimerVaults(feeClaimerVaults) {
        const response = await this.bagsApiClient.post('/token-launch/state/pool-config', {
            feeClaimerVaults: feeClaimerVaults.map((vault) => vault.toBase58()),
        }, {
            timeout: 180 * 1000,
        });
        const configKeys = response.poolConfigKeys.filter((key) => key !== null).map((key) => new web3_js_1.PublicKey(key));
        return configKeys;
    }
    async getTokenClaimStats(tokenMint) {
        const response = await this.bagsApiClient.get('/token-launch/claim-stats', {
            params: {
                tokenMint: tokenMint.toBase58(),
            },
        });
        if (!response.success) {
            throw new Error('Failed to get token claim stats');
        }
        return response.response;
    }
    async getTokenClaimEvents(tokenMint, options = {}) {
        if (!(tokenMint instanceof web3_js_1.PublicKey)) {
            throw new Error('tokenMint must be a PublicKey');
        }
        const limit = options.limit ?? 100;
        const offset = options.offset ?? 0;
        if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
            throw new Error('limit must be an integer between 1 and 100');
        }
        if (!Number.isInteger(offset) || offset < 0) {
            throw new Error('offset must be a non-negative integer');
        }
        const response = await this.bagsApiClient.get('/fee-share/token/claim-events', {
            params: {
                tokenMint: tokenMint.toBase58(),
                limit,
                offset,
            },
        });
        return response.events;
    }
    async getLaunchWalletV2(username, provider) {
        try {
            const response = await this.bagsApiClient.get('/token-launch/fee-share/wallet/v2', {
                params: {
                    username,
                    provider,
                },
            });
            return {
                platformData: response.platformData,
                provider: response.provider,
                wallet: new web3_js_1.PublicKey(response.wallet),
            };
        }
        catch (error) {
            throw new Error(`Failed to get launch wallet for ${provider} user ${username}: ${error?.message}`);
        }
    }
    async getLaunchWalletV2Bulk(items) {
        try {
            const response = await this.bagsApiClient.post('/token-launch/fee-share/wallet/v2/bulk', {
                items,
            });
            return response.map((item) => ({
                username: item.username,
                provider: item.provider,
                platformData: item.platformData,
                wallet: item.wallet ? new web3_js_1.PublicKey(item.wallet) : null,
            }));
        }
        catch (error) {
            throw new Error(`Failed to get launch wallets in bulk: ${error?.message}`);
        }
    }
}
exports.StateService = StateService;
//# sourceMappingURL=state.js.map