@b3dotfun/sdk 0.0.23 → 0.0.24

package/dist/cjs/bondkit/bondkitToken.js

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BondkitToken = void 0;
+const viem_1 = require("viem");
+const accounts_1 = require("viem/accounts");
+const abis_1 = require("./abis");
+const config_1 = require("./config");
+const chains_1 = require("viem/chains");
+// Event ABI snippets for decoding
+const boughtEventAbi = abis_1.BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveBuy");
+const soldEventAbi = abis_1.BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveSell");
+const dexMigrationEventAbi = abis_1.BondkitTokenABI.find(item => item.type === "event" && item.name === "BondkitTokenMigrated");
+class BondkitToken {
+    constructor(contractAddress, walletKey) {
+        const sdkConfig = (0, config_1.getConfig)(chains_1.base.id);
+        this.chain = sdkConfig.chain;
+        this.rpcUrl = sdkConfig.rpcUrl;
+        this.apiEndpoint = sdkConfig.apiEndpoint;
+        if (walletKey && !walletKey.startsWith("0x")) {
+            this.walletKey = `0x${walletKey}`;
+        }
+        else if (walletKey) {
+            this.walletKey = walletKey;
+        }
+        if (!contractAddress || !contractAddress.startsWith("0x")) {
+            throw new Error("Valid contract address is required for BondkitToken.");
+        }
+        this.contractAddress = contractAddress;
+        this.publicClient = (0, viem_1.createPublicClient)({
+            chain: this.chain,
+            transport: (0, viem_1.http)(this.rpcUrl),
+        });
+        this.walletClientInstance = (0, viem_1.createWalletClient)({
+            chain: this.chain,
+            transport: (0, viem_1.http)(this.rpcUrl),
+            account: this.walletKey ? (0, accounts_1.privateKeyToAccount)(this.walletKey) : undefined,
+        });
+        this.contract = (0, viem_1.getContract)({
+            address: this.contractAddress,
+            abi: abis_1.BondkitTokenABI,
+            client: this.walletClientInstance,
+        });
+    }
+    connect(provider) {
+        try {
+            const transport = provider ? (0, viem_1.custom)(provider) : (0, viem_1.http)(this.rpcUrl);
+            this.connectedProvider = provider;
+            this.walletClientInstance = (0, viem_1.createWalletClient)({
+                chain: this.chain,
+                transport,
+                account: this.walletKey ? (0, accounts_1.privateKeyToAccount)(this.walletKey) : undefined,
+            });
+            this.publicClient = (0, viem_1.createPublicClient)({
+                chain: this.chain,
+                transport,
+            });
+            this.contract = (0, viem_1.getContract)({
+                address: this.contractAddress,
+                abi: abis_1.BondkitTokenABI,
+                client: this.walletClientInstance,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error("Connection failed:", error);
+            return false;
+        }
+    }
+    /**
+     * Connects using an EIP-1193 provider and requests accounts, selecting the first one.
+     * Enables frontend wallet flows without requiring a private key.
+     */
+    async connectWithProvider(provider) {
+        try {
+            const transport = (0, viem_1.custom)(provider);
+            this.connectedProvider = provider;
+            // Try to request accounts (prompt user if needed)
+            let addresses = [];
+            try {
+                const result = await provider.request({ method: "eth_requestAccounts" });
+                if (Array.isArray(result))
+                    addresses = result;
+            }
+            catch (requestErr) {
+                try {
+                    const result = await provider.request({ method: "eth_accounts" });
+                    if (Array.isArray(result))
+                        addresses = result;
+                }
+                catch (_) {
+                    // ignore
+                }
+            }
+            const selectedAccount = (addresses?.[0] ?? undefined);
+            this.walletClientInstance = (0, viem_1.createWalletClient)({
+                chain: this.chain,
+                transport,
+                account: selectedAccount,
+            });
+            this.publicClient = (0, viem_1.createPublicClient)({
+                chain: this.chain,
+                transport,
+            });
+            this.contract = (0, viem_1.getContract)({
+                address: this.contractAddress,
+                abi: abis_1.BondkitTokenABI,
+                client: this.walletClientInstance,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error("Connection failed:", error);
+            return false;
+        }
+    }
+    async handleError(error, context) {
+        const defaultMessage = context ? `Error in ${context}:` : "An error occurred:";
+        console.error(defaultMessage, error);
+        // TODO: Add more specific error checks based on BondkitTokenABI error types if needed
+        throw error;
+    }
+    // --- Read Methods (ERC20 + Custom) --- //
+    async name() {
+        try {
+            return await this.contract.read.name();
+        }
+        catch (error) {
+            console.warn("Error fetching token name:", error);
+            return undefined;
+        }
+    }
+    async symbol() {
+        try {
+            return await this.contract.read.symbol();
+        }
+        catch (error) {
+            console.warn("Error fetching token symbol:", error);
+            return undefined;
+        }
+    }
+    async decimals() {
+        try {
+            const dec = await this.contract.read.decimals();
+            return Number(dec);
+        }
+        catch (error) {
+            console.warn("Error fetching token decimals:", error);
+            return undefined;
+        }
+    }
+    async totalSupply() {
+        try {
+            return await this.contract.read.totalSupply();
+        }
+        catch (error) {
+            console.warn("Error fetching token total supply:", error);
+            return undefined;
+        }
+    }
+    async balanceOf(account) {
+        try {
+            return await this.contract.read.balanceOf([account]);
+        }
+        catch (error) {
+            console.warn(`Error fetching balance for ${account}:`, error);
+            return undefined;
+        }
+    }
+    async allowance(owner, spender) {
+        try {
+            return await this.contract.read.allowance([owner, spender]);
+        }
+        catch (error) {
+            console.warn(`Error fetching allowance for owner ${owner} and spender ${spender}:`, error);
+            return undefined;
+        }
+    }
+    async owner() {
+        try {
+            return await this.contract.read.owner();
+        }
+        catch (error) {
+            console.warn("Error fetching token owner or 'owner' function might not exist:", error);
+            return undefined;
+        }
+    }
+    async getTokenDetails() {
+        try {
+            const [name, symbol, decimals, totalSupply, owner] = await Promise.all([
+                this.name(),
+                this.symbol(),
+                this.decimals(),
+                this.totalSupply(),
+                this.owner(),
+            ]);
+            if (name === undefined || symbol === undefined || decimals === undefined || totalSupply === undefined) {
+                console.warn("Failed to retrieve all essential token details.");
+                return undefined;
+            }
+            return {
+                name,
+                symbol,
+                decimals,
+                totalSupply,
+                owner: owner || "0x0000000000000000000000000000000000000000",
+            };
+        }
+        catch (error) {
+            console.warn("Error in getTokenDetails:", error);
+            return undefined;
+        }
+    }
+    // --- Bondkit Specific Read Methods ---
+    async feeRecipient() {
+        try {
+            return await this.contract.read.feeRecipient();
+        }
+        catch (e) {
+            console.warn("Error fetching feeRecipient:", e);
+            return undefined;
+        }
+    }
+    async currentStatus() {
+        try {
+            const status = await this.contract.read.currentStatus();
+            return status;
+        }
+        catch (e) {
+            console.warn("Error fetching currentStatus:", e);
+            return undefined;
+        }
+    }
+    async getCurrentPhase() {
+        try {
+            return await this.contract.read.getCurrentPhase();
+        }
+        catch (e) {
+            console.warn("Error fetching getCurrentPhase:", e);
+            return undefined;
+        }
+    }
+    async getAmountOfTokensToBuy(ethAmount) {
+        try {
+            const value = typeof ethAmount === "string" ? (0, viem_1.parseEther)(ethAmount) : ethAmount;
+            return await this.contract.read.getAmountOfTokensToBuy([value]);
+        }
+        catch (e) {
+            console.warn("Error in getAmountOfTokensToBuy:", e);
+            return undefined;
+        }
+    }
+    async getAmountOfEthToSell(tokenAmount) {
+        try {
+            return await this.contract.read.getAmountOfEthToSell([tokenAmount]);
+        }
+        catch (e) {
+            console.warn("Error in getAmountOfEthToSell:", e);
+            return undefined;
+        }
+    }
+    async getCurrentBondingCurvePricePerToken() {
+        try {
+            return await this.contract.read.getCurrentBondingCurvePricePerToken();
+        }
+        catch (e) {
+            console.warn("Error fetching current bonding curve price:", e);
+            return undefined;
+        }
+    }
+    async totalEthRaisedBonding() {
+        try {
+            return await this.contract.read.totalEthRaisedBonding();
+        }
+        catch (e) {
+            console.warn("Error fetching totalEthRaisedBonding:", e);
+            return undefined;
+        }
+    }
+    async getTotalSupply() {
+        try {
+            return await this.contract.read.totalSupply();
+        }
+        catch (e) {
+            console.warn("Error fetching total supply:", e);
+            return undefined;
+        }
+    }
+    async getPaginatedHolders(startIndex, count = BigInt(1000)) {
+        try {
+            const response = await this.contract.read.getPaginatedHolders([startIndex, count]);
+            const holders = response[0];
+            const balances = response[1];
+            return holders.map((holder, index) => ({
+                address: holder,
+                balance: balances[index],
+            }));
+        }
+        catch (e) {
+            console.warn("Error fetching paginated holders:", e);
+            return [];
+        }
+    }
+    async getBondingProgress() {
+        try {
+            const [progress, raised, threshold] = await this.contract.read.getBondingProgressPercent();
+            return {
+                progress: Number(progress) / 100,
+                raised: Number(raised),
+                threshold: Number(threshold),
+            };
+        }
+        catch (e) {
+            console.warn("Error fetching bonding progress percent:", e);
+            return undefined;
+        }
+    }
+    // --- Transaction History --- //
+    async getTransactionHistory(options) {
+        try {
+            const { userAddress, type, from, to, limit, offset } = options || {};
+            const response = await fetch(this.apiEndpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-service-method": "getTransactionHistory",
+                },
+                body: JSON.stringify({
+                    contractAddress: this.contractAddress,
+                    chainId: this.chain.id,
+                    userAddress,
+                    type,
+                    from,
+                    to: to || Date.now(),
+                    limit: limit || 50,
+                    offset,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const result = await response.json();
+            return result;
+        }
+        catch (e) {
+            console.warn("Error fetching transaction history:", e);
+            return undefined;
+        }
+    }
+    // --- Write Methods --- //
+    async executeWrite(functionName, args, options) {
+        if (!this.walletClientInstance.account && !this.walletKey) {
+            // Try to resolve an account from a connected EIP-1193 provider on-demand
+            if (this.connectedProvider) {
+                try {
+                    const addresses = (await this.connectedProvider.request({ method: "eth_accounts" }));
+                    const selectedAccount = (addresses?.[0] ?? undefined);
+                    if (selectedAccount) {
+                        const transport = (0, viem_1.custom)(this.connectedProvider);
+                        this.walletClientInstance = (0, viem_1.createWalletClient)({
+                            chain: this.chain,
+                            transport,
+                            account: selectedAccount,
+                        });
+                        this.contract = (0, viem_1.getContract)({
+                            address: this.contractAddress,
+                            abi: abis_1.BondkitTokenABI,
+                            client: this.walletClientInstance,
+                        });
+                    }
+                }
+                catch (_) { }
+            }
+            if (!this.walletClientInstance.account && !this.walletKey) {
+                throw new Error("Wallet key not set or client not connected for write operation.");
+            }
+        }
+        const accountToUse = this.walletKey ? (0, accounts_1.privateKeyToAccount)(this.walletKey) : this.walletClientInstance.account;
+        if (!accountToUse)
+            throw new Error("Account for transaction could not be determined.");
+        try {
+            let maxFee = options?.maxFeePerGas;
+            let priorityFee = options?.maxPriorityFeePerGas;
+            if (maxFee === undefined || priorityFee === undefined) {
+                try {
+                    const feeEstimates = await this.publicClient.estimateFeesPerGas();
+                    if (maxFee === undefined) {
+                        maxFee = feeEstimates.maxFeePerGas;
+                    }
+                    if (priorityFee === undefined) {
+                        priorityFee = feeEstimates.maxPriorityFeePerGas;
+                    }
+                }
+                catch (feeError) {
+                    console.warn("Could not estimate fees, will rely on wallet defaults or provided values:", feeError);
+                    maxFee = maxFee ?? undefined;
+                    priorityFee = priorityFee ?? undefined;
+                }
+            }
+            const transactionOptions = {
+                account: accountToUse,
+                chain: this.chain,
+            };
+            if (options?.value !== undefined)
+                transactionOptions.value = options.value;
+            if (options?.gas !== undefined)
+                transactionOptions.gas = options.gas;
+            if (maxFee !== undefined)
+                transactionOptions.maxFeePerGas = maxFee;
+            if (priorityFee !== undefined)
+                transactionOptions.maxPriorityFeePerGas = priorityFee;
+            const hash = await this.contract.write[functionName](args, transactionOptions);
+            return hash;
+        }
+        catch (error) {
+            return this.handleError(error, functionName);
+        }
+    }
+    async initialize(config, options) {
+        return this.executeWrite("initialize", [config], options);
+    }
+    async transfer(to, amount, options) {
+        return this.executeWrite("transfer", [to, amount], options);
+    }
+    async approve(spender, amount, options) {
+        return this.executeWrite("approve", [spender, amount], options);
+    }
+    async transferFrom(from, to, amount, options) {
+        return this.executeWrite("transferFrom", [from, to, amount], options);
+    }
+    /** Buy tokens with ETH. Payable function. */
+    async buy(minTokensOut, ethAmount, options) {
+        if (!boughtEventAbi)
+            console.warn("Bought event ABI not found for event decoding.");
+        const value = typeof ethAmount === "string" ? (0, viem_1.parseEther)(ethAmount) : ethAmount;
+        return this.executeWrite("buy", [minTokensOut], { ...options, value });
+    }
+    /** Sell tokens for ETH. */
+    async sell(tokenAmount, minEthOut, options) {
+        if (!soldEventAbi)
+            console.warn("Sold event ABI not found for event decoding.");
+        return this.executeWrite("sell", [tokenAmount, minEthOut], options);
+    }
+    /** Migrate liquidity to DEX. Only callable by owner/migrationAdmin based on typical patterns. */
+    async migrateToDex(options) {
+        if (!dexMigrationEventAbi)
+            console.warn("DexMigration event ABI not found for event decoding.");
+        return this.executeWrite("migrateToDex", [], options);
+    }
+    async transferTokenOwnership(newOwner, options) {
+        return this.executeWrite("transferOwnership", [newOwner], options);
+    }
+    async renounceTokenOwnership(options) {
+        return this.executeWrite("renounceOwnership", [], options);
+    }
+}
+exports.BondkitToken = BondkitToken;

package/dist/cjs/bondkit/bondkitTokenFactory.d.ts

@@ -0,0 +1,60 @@
+import type { Address, EIP1193Provider, Hex } from "viem";
+import { SupportedChainId } from "./config";
+import type { BondkitTokenConfig } from "./types";
+export declare class BondkitTokenFactory {
+    private contract;
+    private publicClient;
+    private contractAddress;
+    private chain;
+    private walletKey?;
+    private rpcUrl;
+    private walletClientInstance;
+    private connectedProvider?;
+    constructor(chainId: SupportedChainId, walletKey?: string);
+    connect(provider?: EIP1193Provider): boolean;
+    /**
+     * Connects using an EIP-1193 provider and requests accounts, selecting the first one.
+     * Enables frontend wallet flows without requiring a private key.
+     */
+    connectWithProvider(provider: EIP1193Provider): Promise<boolean>;
+    /**
+     * Ensure we have an account set for write operations.
+     * If not, try to resolve from a connected provider and reinitialize the client.
+     */
+    private ensureWriteAccount;
+    private handleError;
+    /**
+     * Deploys a new Bondkit token using the factory.
+     * @param config The configuration for the token to be deployed.
+     * @returns The address of the newly created BondkitToken.
+     */
+    deployBondkitToken(configArg: BondkitTokenConfig): Promise<Address>;
+    /**
+     * Gets the configuration of a deployed Bondkit token.
+     * @param tokenAddress The address of the Bondkit token.
+     * @returns The configuration object for the token.
+     */
+    getBondkitTokenConfig(tokenAddress: Address): Promise<BondkitTokenConfig | undefined>;
+    /**
+     * Gets a list of all Bondkit tokens deployed by this factory.
+     * @returns An array of token addresses.
+     */
+    getDeployedBondkitTokens(): Promise<readonly Address[]>;
+    /**
+     * Gets the owner of the factory contract.
+     * @returns The address of the owner.
+     */
+    getOwner(): Promise<Address | undefined>;
+    /**
+     * Gets the implementation address used for new Bondkit token clones.
+     * @returns The address of the BondkitToken implementation contract.
+     */
+    getBondkitTokenImplementation(): Promise<Address | undefined>;
+    /**
+     * Transfers ownership of the factory contract to a new owner.
+     * Requires the current owner to call this method.
+     * @param newOwner The address of the new owner.
+     * @returns A promise that resolves with the transaction hash.
+     */
+    transferOwnership(newOwner: Address): Promise<Hex | undefined>;
+}