@b3dotfun/sdk 0.0.25-alpha.0 → 0.0.25-alpha.2

package/dist/esm/bondkit/bondkitToken.d.ts

@@ -1,6 +1,6 @@
 import type { Address, EIP1193Provider, GetContractReturnType, Hex, PublicClient, WalletClient } from "viem";
 import { BondkitTokenABI } from "./abis";
-import type { TokenDetails, TokenStatus, BondkitTokenInitializationConfig, GetTransactionHistoryOptions, TransactionResponse } from "./types";
+import type { BondkitTokenInitializationConfig, GetTransactionHistoryOptions, TokenDetails, TokenStatus, TransactionResponse } from "./types";
 type ExecuteWriteOptions = {
     value?: bigint;
     gas?: bigint;
@@ -17,6 +17,7 @@ export declare class BondkitToken {
     private apiEndpoint;
     private walletClientInstance;
     private connectedProvider?;
+    private tradingToken?;
     constructor(contractAddress: string, walletKey?: string);
     connect(provider?: EIP1193Provider): boolean;
     /**
@@ -30,6 +31,8 @@ export declare class BondkitToken {
     decimals(): Promise<number | undefined>;
     totalSupply(): Promise<bigint | undefined>;
     balanceOf(account: Address): Promise<bigint | undefined>;
+    getTradingTokenBalanceOf(account: Address): Promise<bigint | undefined>;
+    getTradingTokenAddress(): Promise<Address | undefined>;
     allowance(owner: Address, spender: Address): Promise<bigint | undefined>;
     owner(): Promise<Address | undefined>;
     getTokenDetails(): Promise<TokenDetails | undefined>;
@@ -37,9 +40,9 @@ export declare class BondkitToken {
     currentStatus(): Promise<TokenStatus | undefined>;
     getCurrentPhase(): Promise<string | undefined>;
     getAmountOfTokensToBuy(ethAmount: bigint | string): Promise<bigint | undefined>;
-    getAmountOfEthToSell(tokenAmount: bigint): Promise<bigint | undefined>;
+    getAmountOfTradingTokensToSell(amount: bigint): Promise<bigint | undefined>;
     getCurrentBondingCurvePricePerToken(): Promise<bigint | undefined>;
-    totalEthRaisedBonding(): Promise<bigint | undefined>;
+    totalRaisedBonding(): Promise<bigint | undefined>;
     getTotalSupply(): Promise<bigint | undefined>;
     getPaginatedHolders(startIndex: bigint, count?: bigint): Promise<{
         address: Address;
@@ -57,7 +60,7 @@ export declare class BondkitToken {
     approve(spender: Address, amount: bigint, options?: ExecuteWriteOptions): Promise<Hex | undefined>;
     transferFrom(from: Address, to: Address, amount: bigint, options?: ExecuteWriteOptions): Promise<Hex | undefined>;
     /** Buy tokens with ETH. Payable function. */
-    buy(minTokensOut: bigint, ethAmount: bigint | string, options?: ExecuteWriteOptions): Promise<Hex | undefined>;
+    buy(amount: bigint | string, minTokensOut: bigint, options?: ExecuteWriteOptions): Promise<Hex | undefined>;
     /** Sell tokens for ETH. */
     sell(tokenAmount: bigint, minEthOut: bigint, options?: ExecuteWriteOptions): Promise<Hex | undefined>;
     /** Migrate liquidity to DEX. Only callable by owner/migrationAdmin based on typical patterns. */

package/dist/esm/bondkit/bondkitToken.js

@@ -1,8 +1,8 @@
-import { createPublicClient, createWalletClient, custom, getContract, http, parseEther } from "viem";
+import { createPublicClient, createWalletClient, custom, erc20Abi, getContract, http, parseEther } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
+import { base } from "viem/chains";
 import { BondkitTokenABI } from "./abis/index.js";
 import { getConfig } from "./config.js";
-import { base } from "viem/chains";
 // Event ABI snippets for decoding
 const boughtEventAbi = BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveBuy");
 const soldEventAbi = BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveSell");
@@ -37,6 +37,9 @@ export class BondkitToken {
             abi: BondkitTokenABI,
             client: this.walletClientInstance,
         });
+        this.contract.read.tradingToken().then(tradingToken => {
+            this.tradingToken = tradingToken;
+        });
     }
     connect(provider) {
         try {
@@ -163,6 +166,41 @@ export class BondkitToken {
             return undefined;
         }
     }
+    async getTradingTokenBalanceOf(account) {
+        try {
+            if (!this.tradingToken) {
+                console.warn("Trading token address not available");
+                return undefined;
+            }
+            // If trading token is ETH (zero address), get ETH balance
+            if (this.tradingToken === "0x0000000000000000000000000000000000000000") {
+                return await this.publicClient.getBalance({ address: account });
+            }
+            // For ERC20 trading tokens, get token balance
+            const tradingTokenContract = getContract({
+                address: this.tradingToken,
+                abi: erc20Abi,
+                client: this.publicClient, // Use public client for read operations
+            });
+            return await tradingTokenContract.read.balanceOf([account]);
+        }
+        catch (error) {
+            console.warn(`Error fetching trading token balance for ${account}:`, error);
+            return undefined;
+        }
+    }
+    async getTradingTokenAddress() {
+        try {
+            if (!this.tradingToken) {
+                this.tradingToken = (await this.contract.read.tradingToken());
+            }
+            return this.tradingToken;
+        }
+        catch (error) {
+            console.warn("Error fetching trading token address:", error);
+            return undefined;
+        }
+    }
     async allowance(owner, spender) {
         try {
             return await this.contract.read.allowance([owner, spender]);
@@ -246,12 +284,12 @@ export class BondkitToken {
             return undefined;
         }
     }
-    async getAmountOfEthToSell(tokenAmount) {
+    async getAmountOfTradingTokensToSell(amount) {
         try {
-            return await this.contract.read.getAmountOfEthToSell([tokenAmount]);
+            return await this.contract.read.getAmountOfTradingTokensToSell([amount]);
         }
         catch (e) {
-            console.warn("Error in getAmountOfEthToSell:", e);
+            console.warn("Error in getAmountOfTradingTokensToSell:", e);
             return undefined;
         }
     }
@@ -264,12 +302,12 @@ export class BondkitToken {
             return undefined;
         }
     }
-    async totalEthRaisedBonding() {
+    async totalRaisedBonding() {
         try {
-            return await this.contract.read.totalEthRaisedBonding();
+            return await this.contract.read.totalRaisedBonding();
         }
         catch (e) {
-            console.warn("Error fetching totalEthRaisedBonding:", e);
+            console.warn("Error fetching totalRaisedBonding:", e);
             return undefined;
         }
     }
@@ -425,11 +463,48 @@ export class BondkitToken {
         return this.executeWrite("transferFrom", [from, to, amount], options);
     }
     /** Buy tokens with ETH. Payable function. */
-    async buy(minTokensOut, ethAmount, options) {
+    async buy(amount, minTokensOut, options) {
         if (!boughtEventAbi)
             console.warn("Bought event ABI not found for event decoding.");
-        const value = typeof ethAmount === "string" ? parseEther(ethAmount) : ethAmount;
-        return this.executeWrite("buy", [minTokensOut], { ...options, value });
+        if (this.tradingToken === "0x0000000000000000000000000000000000000000") {
+            const value = typeof amount === "string" ? parseEther(amount) : amount;
+            return this.executeWrite("buy", [minTokensOut], { ...options, value });
+        }
+        else {
+            // For ERC20 trading tokens, we need to approve first, then call buy
+            const tradingTokenContract = getContract({
+                address: this.tradingToken,
+                abi: erc20Abi,
+                client: this.walletClientInstance,
+            });
+            const currentAllowance = await tradingTokenContract.read.allowance([
+                this.walletClientInstance.account?.address,
+                this.contractAddress,
+            ]);
+            const amountBigInt = typeof amount === "string" ? parseEther(amount) : BigInt(amount);
+            if (currentAllowance < amountBigInt) {
+                // Get account for the approve transaction
+                const accountToUse = this.walletKey ? privateKeyToAccount(this.walletKey) : this.walletClientInstance.account;
+                if (!accountToUse)
+                    throw new Error("Account for transaction could not be determined.");
+                // Create approve options with required fields but without value (ERC20 approve doesn't need ETH)
+                const approveOptions = {
+                    account: accountToUse,
+                    chain: this.chain,
+                };
+                // Add optional transaction parameters if provided
+                if (options?.gas !== undefined)
+                    approveOptions.gas = options.gas;
+                if (options?.maxFeePerGas !== undefined)
+                    approveOptions.maxFeePerGas = options.maxFeePerGas;
+                if (options?.maxPriorityFeePerGas !== undefined)
+                    approveOptions.maxPriorityFeePerGas = options.maxPriorityFeePerGas;
+                const approveTx = await tradingTokenContract.write.approve([this.contractAddress, amountBigInt], approveOptions);
+                await this.publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+            // Now call the buy function with the trading token amount
+            return this.executeWrite("buy", [amountBigInt, minTokensOut], options);
+        }
     }
     /** Sell tokens for ETH. */
     async sell(tokenAmount, minEthOut, options) {

package/dist/esm/bondkit/constants.js

@@ -1,2 +1,2 @@
-export const BaseBondkitTokenFactoryContractAddress = "0x2d9876CCee96771F91D53e0bc4F7f4044d3bE345";
+export const BaseBondkitTokenFactoryContractAddress = "0x0ccA36e9BE8Fdf456dE4BC20b378B1560Aeb6653";
 export const BaseMainnetRpcUrl = "https://base-rpc.publicnode.com";