@b3dotfun/sdk 0.0.40 → 0.0.41-alpha.0

package/dist/cjs/bondkit/bondkitTokenFactory.js

@@ -8,14 +8,14 @@ const config_1 = require("./config");
 // Define the event ABI snippet for BondkitTokenCreated specifically for decoding
 const bondkitTokenCreatedEventAbi = abis_1.BondkitTokenFactoryABI.find(item => item.type === "event" && item.name === "BondkitTokenCreated");
 class BondkitTokenFactory {
-    constructor(chainId, walletKey) {
+    constructor(chainId, walletKey, rpcUrl) {
         if (walletKey && !walletKey.startsWith("0x")) {
             this.walletKey = `0x${walletKey}`;
         }
         else if (walletKey) {
             this.walletKey = walletKey;
         }
-        const config = (0, config_1.getConfig)(chainId);
+        const config = (0, config_1.getConfig)(chainId, rpcUrl);
         this.chain = config.chain;
         this.contractAddress = config.factoryAddress;
         this.rpcUrl = config.rpcUrl;

package/dist/cjs/bondkit/components/TradingView.js

@@ -2,16 +2,15 @@
 "use client";
 Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("react/jsx-runtime");
-const cdn_loader_1 = require("./utils/cdn-loader");
-const format_1 = require("./utils/format");
 const lucide_react_1 = require("lucide-react");
 const react_1 = require("react");
+const cdn_loader_1 = require("./utils/cdn-loader");
+const format_1 = require("./utils/format");
 // TradingView will be available on window after loading from CDN
 // Datafeed will be implemented inline
 // Mock loading overlay - replace with your actual loading component
 const GifLoadingOverlay = ({ className }) => ((0, jsx_runtime_1.jsx)("div", { className: `absolute inset-0 flex items-center justify-center bg-white/50 backdrop-blur-sm ${className || ""}`, children: (0, jsx_runtime_1.jsx)(lucide_react_1.Loader2, { className: "text-secondary-grey h-8 w-8 animate-spin" }) }));
 const TradingView = ({ className, tokenAddress, tokenSymbol }) => {
-    const theme = "light";
     // Use token info for the current trade
     const currentTrade = {
         product_id: tokenAddress && tokenSymbol ? `${tokenSymbol}-${tokenAddress}` : "BONDKIT",
@@ -247,7 +246,7 @@ const TradingView = ({ className, tokenAddress, tokenSymbol }) => {
                 tvWidgetRef.current = null;
             }
         };
-    }, [theme, librariesLoaded]);
+    }, [librariesLoaded, currentTrade?.product_id, tradingViewDefaultInterval, tradingViewTimezone]);
     (0, react_1.useEffect)(() => {
         if (chartLoaded &&
             currentTrade?.product_id &&

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

@@ -7,4 +7,4 @@ export interface Config {
     apiEndpoint: string;
 }
 export type SupportedChainId = typeof base.id;
-export declare const getConfig: (chainId: number) => Config;
+export declare const getConfig: (chainId: number, rpcUrl?: string) => Config;

package/dist/cjs/bondkit/config.js

@@ -9,9 +9,12 @@ const baseMainnetConfig = {
     factoryAddress: constants_1.BaseBondkitTokenFactoryContractAddress,
     apiEndpoint: "https://api.b3.fun/bondkit-tokens",
 };
-const getConfig = (chainId) => {
+const getConfig = (chainId, rpcUrl) => {
     if (chainId === chains_1.base.id) {
-        return baseMainnetConfig;
+        return {
+            ...baseMainnetConfig,
+            rpcUrl: rpcUrl || constants_1.BaseMainnetRpcUrl,
+        };
     }
     throw new Error(`Unsupported chainId: ${chainId}. This SDK is configured for Base (Chain ID: ${chains_1.base.id}) only.`);
 };

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

@@ -1,3 +1,7 @@
 import type { Address } from "viem";
 export declare const BaseBondkitTokenFactoryContractAddress: Address;
 export declare const BaseMainnetRpcUrl = "https://base-rpc.publicnode.com";
+export declare const UniversalRouterAddress: Address;
+export declare const QuoterAddress: Address;
+export declare const Permit2Address: Address;
+export declare const B3TokenAddress: Address;

package/dist/cjs/bondkit/constants.js

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseMainnetRpcUrl = exports.BaseBondkitTokenFactoryContractAddress = void 0;
+exports.B3TokenAddress = exports.Permit2Address = exports.QuoterAddress = exports.UniversalRouterAddress = exports.BaseMainnetRpcUrl = exports.BaseBondkitTokenFactoryContractAddress = void 0;
 exports.BaseBondkitTokenFactoryContractAddress = "0x5d641bbB206d4B5585eCCd919F36270200A9A2Ad";
 exports.BaseMainnetRpcUrl = "https://base-rpc.publicnode.com";
+// Uniswap V4 addresses on Base
+exports.UniversalRouterAddress = "0x6ff5693b99212da76ad316178a184ab56d299b43";
+exports.QuoterAddress = "0x0d5e0f971ed27fbff6c2837bf31316121532048d";
+exports.Permit2Address = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+exports.B3TokenAddress = "0xB3B32F9f8827D4634fE7d973Fa1034Ec9fdDB3B3";

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

@@ -4,4 +4,5 @@ export * from "./config";
 export * from "./constants";
 export * from "./types";
 export * from "./abis";
+export { BondkitSwapService } from "./swapService";
 export { default as TradingView } from "./components/TradingView";

package/dist/cjs/bondkit/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradingView = void 0;
+exports.TradingView = exports.BondkitSwapService = void 0;
 // Core exports
 __exportStar(require("./bondkitToken"), exports);
 __exportStar(require("./bondkitTokenFactory"), exports);
@@ -28,6 +28,9 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./types"), exports);
 // ABIs
 __exportStar(require("./abis"), exports);
+// Swap functionality
+var swapService_1 = require("./swapService");
+Object.defineProperty(exports, "BondkitSwapService", { enumerable: true, get: function () { return swapService_1.BondkitSwapService; } });
 // Components
 var TradingView_1 = require("./components/TradingView");
 Object.defineProperty(exports, "TradingView", { enumerable: true, get: function () { return __importDefault(TradingView_1).default; } });

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

@@ -0,0 +1,43 @@
+import type { Address, WalletClient } from "viem";
+import type { SwapQuote } from "./types";
+interface SwapParams {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    tokenInDecimals: number;
+    tokenOutDecimals: number;
+    slippageTolerance: number;
+    recipient: Address;
+    deadline?: number;
+}
+/**
+ * Internal swap service for handling Uniswap V4 swaps between trading token and bondkit token
+ */
+export declare class BondkitSwapService {
+    private v4Config;
+    private configInitialized;
+    private readonly bondkitTokenAddress;
+    private readonly publicClient;
+    constructor(bondkitTokenAddress: Address);
+    /**
+     * Initialize V4 pool configuration from bondkit token contract
+     */
+    private initializeV4Config;
+    /**
+     * Get V4 pool configuration
+     */
+    private getV4Config;
+    /**
+     * Handle token approvals for swap
+     */
+    private handleTokenApprovals;
+    /**
+     * Get swap quote
+     */
+    getSwapQuote(params: SwapParams): Promise<SwapQuote | null>;
+    /**
+     * Execute swap transaction
+     */
+    executeSwap(params: SwapParams, walletClient: WalletClient): Promise<string | null>;
+}
+export {};

package/dist/cjs/bondkit/swapService.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BondkitSwapService = void 0;
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const constants_1 = require("./constants");
+// Minimal ABIs needed for swap functionality
+const UNIVERSAL_ROUTER_ABI = [
+    {
+        inputs: [
+            { name: "commands", type: "bytes" },
+            { name: "inputs", type: "bytes[]" },
+            { name: "deadline", type: "uint256" },
+        ],
+        name: "execute",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+];
+const QUOTER_ABI = [
+    {
+        inputs: [
+            {
+                components: [
+                    {
+                        components: [
+                            { internalType: "Currency", name: "currency0", type: "address" },
+                            { internalType: "Currency", name: "currency1", type: "address" },
+                            { internalType: "uint24", name: "fee", type: "uint24" },
+                            { internalType: "int24", name: "tickSpacing", type: "int24" },
+                            { internalType: "contract IHooks", name: "hooks", type: "address" },
+                        ],
+                        internalType: "struct PoolKey",
+                        name: "poolKey",
+                        type: "tuple",
+                    },
+                    { internalType: "bool", name: "zeroForOne", type: "bool" },
+                    { internalType: "uint128", name: "exactAmount", type: "uint128" },
+                    { internalType: "bytes", name: "hookData", type: "bytes" },
+                ],
+                internalType: "struct IV4Quoter.QuoteExactSingleParams",
+                name: "params",
+                type: "tuple",
+            },
+        ],
+        name: "quoteExactInputSingle",
+        outputs: [
+            { internalType: "uint256", name: "amountOut", type: "uint256" },
+            { internalType: "uint256", name: "gasEstimate", type: "uint256" },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];
+const ERC20_ABI = [
+    {
+        inputs: [
+            { name: "spender", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+        name: "approve",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { name: "owner", type: "address" },
+            { name: "spender", type: "address" },
+        ],
+        name: "allowance",
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+const PERMIT2_ABI = [
+    {
+        inputs: [
+            { name: "token", type: "address" },
+            { name: "spender", type: "address" },
+            { name: "amount", type: "uint160" },
+            { name: "expiration", type: "uint48" },
+        ],
+        name: "approve",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { name: "owner", type: "address" },
+            { name: "token", type: "address" },
+            { name: "spender", type: "address" },
+        ],
+        name: "allowance",
+        outputs: [
+            { name: "amount", type: "uint160" },
+            { name: "expiration", type: "uint48" },
+            { name: "nonce", type: "uint48" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+const TOKEN_V4_CONFIG_ABI = [
+    {
+        inputs: [],
+        name: "v4Hook",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "v4PoolFee",
+        outputs: [{ internalType: "uint24", name: "", type: "uint24" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "v4TickSpacing",
+        outputs: [{ internalType: "int24", name: "", type: "int24" }],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+// Command and action constants
+const COMMANDS = {
+    V4_SWAP: "0x10",
+};
+const V4_ACTIONS = {
+    SWAP_EXACT_IN_SINGLE: 6,
+    TAKE_ALL: 15,
+    SETTLE_ALL: 12,
+};
+/**
+ * Internal swap service for handling Uniswap V4 swaps between trading token and bondkit token
+ */
+class BondkitSwapService {
+    constructor(bondkitTokenAddress) {
+        this.v4Config = null;
+        this.configInitialized = false;
+        this.bondkitTokenAddress = bondkitTokenAddress;
+        this.publicClient = (0, viem_1.createPublicClient)({
+            chain: chains_1.base,
+            transport: (0, viem_1.http)(constants_1.BaseMainnetRpcUrl),
+        });
+    }
+    /**
+     * Initialize V4 pool configuration from bondkit token contract
+     */
+    async initializeV4Config() {
+        if (this.configInitialized) {
+            return;
+        }
+        try {
+            const tokenContract = (0, viem_1.getContract)({
+                address: this.bondkitTokenAddress,
+                abi: TOKEN_V4_CONFIG_ABI,
+                client: this.publicClient,
+            });
+            const [hook, fee, tickSpacing] = await Promise.all([
+                tokenContract.read.v4Hook(),
+                tokenContract.read.v4PoolFee(),
+                tokenContract.read.v4TickSpacing(),
+            ]);
+            this.v4Config = {
+                hook: hook,
+                fee: Number(fee),
+                tickSpacing: Number(tickSpacing),
+            };
+            this.configInitialized = true;
+        }
+        catch (error) {
+            console.warn("Failed to initialize V4 configuration:", error);
+            // Use fallback configuration
+            this.v4Config = {
+                hook: "0xB36f4A2FB18b745ef8eD31452781a463d2B3f0cC",
+                fee: 30000,
+                tickSpacing: 60,
+            };
+            this.configInitialized = true;
+        }
+    }
+    /**
+     * Get V4 pool configuration
+     */
+    async getV4Config() {
+        await this.initializeV4Config();
+        if (!this.v4Config) {
+            throw new Error("Failed to initialize V4 configuration");
+        }
+        return this.v4Config;
+    }
+    /**
+     * Handle token approvals for swap
+     */
+    async handleTokenApprovals(tokenAddress, amountIn, walletClient, deadline) {
+        // Skip approvals for ETH
+        if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+            return;
+        }
+        const userAddress = walletClient.account?.address;
+        if (!userAddress) {
+            throw new Error("No user address found");
+        }
+        const erc20Contract = (0, viem_1.getContract)({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            client: walletClient,
+        });
+        const permit2Contract = (0, viem_1.getContract)({
+            address: constants_1.Permit2Address,
+            abi: PERMIT2_ABI,
+            client: walletClient,
+        });
+        // Check ERC20 allowance to Permit2
+        const currentAllowance = (await erc20Contract.read.allowance([userAddress, constants_1.Permit2Address]));
+        const requiredAmount = BigInt(amountIn);
+        if (currentAllowance < requiredAmount) {
+            await erc20Contract.write.approve([constants_1.Permit2Address, BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")], {
+                account: userAddress,
+                chain: chains_1.base,
+            });
+        }
+        // Check Permit2 allowance for Universal Router
+        const permit2Allowance = (await permit2Contract.read.allowance([
+            userAddress,
+            tokenAddress,
+            constants_1.UniversalRouterAddress,
+        ]));
+        const [currentPermit2Amount, expiration] = permit2Allowance;
+        const currentTime = Math.floor(Date.now() / 1000);
+        const isExpired = expiration <= currentTime;
+        if (currentPermit2Amount < requiredAmount || isExpired) {
+            await permit2Contract.write.approve([tokenAddress, constants_1.UniversalRouterAddress, BigInt("0xffffffffffffffffffffffffffffffffffffff"), Number(deadline)], {
+                account: userAddress,
+                chain: chains_1.base,
+            });
+        }
+    }
+    /**
+     * Get swap quote
+     */
+    async getSwapQuote(params) {
+        try {
+            const { tokenIn, tokenOut, amountIn, tokenInDecimals, tokenOutDecimals, slippageTolerance } = params;
+            const v4Config = await this.getV4Config();
+            const amountInWei = (0, viem_1.parseUnits)(amountIn, tokenInDecimals);
+            // Determine token order for pool
+            const currency0 = tokenIn.toLowerCase() < tokenOut.toLowerCase() ? tokenIn : tokenOut;
+            const currency1 = tokenIn.toLowerCase() < tokenOut.toLowerCase() ? tokenOut : tokenIn;
+            const zeroForOne = tokenIn.toLowerCase() === currency0.toLowerCase();
+            const poolKey = {
+                currency0: currency0,
+                currency1: currency1,
+                fee: v4Config.fee,
+                tickSpacing: v4Config.tickSpacing,
+                hooks: v4Config.hook,
+            };
+            const quoteParams = {
+                poolKey,
+                zeroForOne,
+                exactAmount: BigInt(amountInWei.toString()),
+                hookData: "0x",
+            };
+            const { result } = await this.publicClient.simulateContract({
+                address: constants_1.QuoterAddress,
+                abi: QUOTER_ABI,
+                functionName: "quoteExactInputSingle",
+                args: [quoteParams],
+            });
+            const [amountOut] = result;
+            const amountOutRaw = (0, viem_1.formatUnits)(amountOut, tokenOutDecimals);
+            const amountOutFormatted = parseFloat(amountOutRaw).toFixed(Math.min(6, tokenOutDecimals));
+            // Calculate minimum amount out with slippage
+            const slippageMultiplier = (100 - slippageTolerance) / 100;
+            const amountOutMinRaw = parseFloat(amountOutFormatted) * slippageMultiplier;
+            const amountOutMin = amountOutMinRaw.toFixed(tokenOutDecimals);
+            // Simple execution price calculation
+            const rate = parseFloat(amountOutFormatted) / parseFloat(amountIn);
+            const executionPrice = `1 = ${rate.toFixed(6)}`;
+            return {
+                amountOut: amountOutFormatted,
+                amountOutMin,
+                priceImpact: "0.0", // Simplified
+                executionPrice,
+                fee: (v4Config.fee / 10000).toString(),
+            };
+        }
+        catch (error) {
+            console.warn("Error getting swap quote:", error);
+            return null;
+        }
+    }
+    /**
+     * Execute swap transaction
+     */
+    async executeSwap(params, walletClient) {
+        try {
+            const { tokenIn, tokenOut, amountIn, tokenInDecimals, tokenOutDecimals, deadline } = params;
+            const swapDeadline = deadline || Math.floor(Date.now() / 1000) + 3600;
+            if (!walletClient.account) {
+                throw new Error("Wallet client must have an account");
+            }
+            const amountInWei = (0, viem_1.parseUnits)(amountIn, tokenInDecimals);
+            // Handle token approvals
+            await this.handleTokenApprovals(tokenIn, amountInWei.toString(), walletClient, swapDeadline);
+            // Get quote for minimum amount out
+            const quote = await this.getSwapQuote(params);
+            if (!quote) {
+                throw new Error("Unable to get swap quote");
+            }
+            const amountOutMinimum = (0, viem_1.parseUnits)(quote.amountOutMin, tokenOutDecimals);
+            const v4Config = await this.getV4Config();
+            // Determine token order
+            const currency0 = tokenIn.toLowerCase() < tokenOut.toLowerCase() ? tokenIn : tokenOut;
+            const currency1 = tokenIn.toLowerCase() < tokenOut.toLowerCase() ? tokenOut : tokenIn;
+            const zeroForOne = tokenIn.toLowerCase() === currency0.toLowerCase();
+            const poolKey = [currency0, currency1, v4Config.fee, v4Config.tickSpacing, v4Config.hook];
+            // Encode V4 actions
+            const actions = [
+                {
+                    type: V4_ACTIONS.SWAP_EXACT_IN_SINGLE,
+                    params: [poolKey, zeroForOne, amountInWei, amountOutMinimum, "0x"],
+                },
+                {
+                    type: V4_ACTIONS.TAKE_ALL,
+                    params: [(zeroForOne ? currency1 : currency0), BigInt(0)],
+                },
+                {
+                    type: V4_ACTIONS.SETTLE_ALL,
+                    params: [(zeroForOne ? currency0 : currency1), amountInWei],
+                },
+            ];
+            // Encode actions
+            const actionTypes = actions.map(action => action.type);
+            const actionsBytes = ("0x" + actionTypes.map(type => type.toString(16).padStart(2, "0")).join(""));
+            const actionParams = actions.map(action => {
+                switch (action.type) {
+                    case V4_ACTIONS.SWAP_EXACT_IN_SINGLE:
+                        return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("((address,address,uint24,int24,address),bool,uint128,uint128,bytes)"), [action.params]);
+                    case V4_ACTIONS.TAKE_ALL:
+                        return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("address,uint256"), action.params);
+                    case V4_ACTIONS.SETTLE_ALL:
+                        return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("address,uint256"), action.params);
+                    default:
+                        return "0x00";
+                }
+            });
+            const v4SwapInput = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("bytes,bytes[]"), [actionsBytes, actionParams]);
+            const commands = COMMANDS.V4_SWAP;
+            const inputs = [v4SwapInput];
+            // Execute swap
+            const universalRouter = (0, viem_1.getContract)({
+                address: constants_1.UniversalRouterAddress,
+                abi: UNIVERSAL_ROUTER_ABI,
+                client: walletClient,
+            });
+            const txHash = await universalRouter.write.execute([commands, inputs, BigInt(swapDeadline)], {
+                account: walletClient.account,
+                chain: chains_1.base,
+                value: tokenIn === "0x0000000000000000000000000000000000000000" ? amountInWei : BigInt(0),
+            });
+            return txHash;
+        }
+        catch (error) {
+            console.warn("Error executing swap:", error);
+            return null;
+        }
+    }
+}
+exports.BondkitSwapService = BondkitSwapService;

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

@@ -49,10 +49,9 @@ export type DexMigrationEventArgs = {
     ethForFeeRecipient: bigint;
 };
 export declare enum TokenStatus {
-    Inactive = 0,// Assuming mapping from ABI, verify actual enum values if specified elsewhere
-    BondingPhase = 1,
-    DexPhase = 2,
-    Migrated = 3
+    Uninitialized = 0,
+    Bonding = 1,
+    Dex = 2
 }
 export interface GetTransactionHistoryOptions {
     userAddress?: Address;
@@ -80,3 +79,10 @@ export interface TransactionResponse {
     skip: number;
     data: Transaction[];
 }
+export interface SwapQuote {
+    amountOut: string;
+    amountOutMin: string;
+    priceImpact: string;
+    executionPrice: string;
+    fee: string;
+}

package/dist/cjs/bondkit/types.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenStatus = void 0;
-// Enum for Status (used in BondkitToken ABI)
+// Enum for Status (matches contract Status enum exactly)
 var TokenStatus;
 (function (TokenStatus) {
-    TokenStatus[TokenStatus["Inactive"] = 0] = "Inactive";
-    TokenStatus[TokenStatus["BondingPhase"] = 1] = "BondingPhase";
-    TokenStatus[TokenStatus["DexPhase"] = 2] = "DexPhase";
-    TokenStatus[TokenStatus["Migrated"] = 3] = "Migrated";
+    TokenStatus[TokenStatus["Uninitialized"] = 0] = "Uninitialized";
+    TokenStatus[TokenStatus["Bonding"] = 1] = "Bonding";
+    TokenStatus[TokenStatus["Dex"] = 2] = "Dex";
 })(TokenStatus || (exports.TokenStatus = TokenStatus = {}));

package/dist/cjs/global-account/react/components/B3Provider/B3Provider.d.ts

@@ -1,13 +1,12 @@
 import { PermissionsConfig } from "../../../../global-account/types/permissions";
+import "@reservoir0x/relay-kit-ui/styles.css";
 import { Account } from "thirdweb/wallets";
 import { ClientType } from "../../../client-manager";
 import { B3ContextType } from "./types";
-import "@reservoir0x/relay-kit-ui/styles.css";
-export declare const wagmiConfig: import("wagmi").Config<readonly [import("viem").Chain, ...import("viem").Chain[]], any, readonly import("wagmi").CreateConnectorFn[]>;
 /**
  * Main B3Provider component
  */
-export declare function B3Provider({ theme, children, accountOverride, environment, automaticallySetFirstEoa, simDuneApiKey, toaster, clientType, }: {
+export declare function B3Provider({ theme, children, accountOverride, environment, automaticallySetFirstEoa, simDuneApiKey, toaster, clientType, rpcUrls, partnerId, }: {
     theme: "light" | "dark";
     children: React.ReactNode;
     accountOverride?: Account;
@@ -19,6 +18,8 @@ export declare function B3Provider({ theme, children, accountOverride, environme
         style?: React.CSSProperties;
     };
     clientType?: ClientType;
+    rpcUrls?: Record<number, string>;
+    partnerId?: string;
 }): import("react/jsx-runtime").JSX.Element;
 /**
  * Inner provider component that provides the actual B3Context