@baseline-markets/sdk 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -2,8 +2,13 @@
 
 var viem = require('viem');
 var chains = require('viem/chains');
+var actions = require('viem/actions');
 
-// ../contracts/abis/external/chainlinkOracle.ts
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // ../contracts/abis/external/erc20.ts
 var erc20 = [
@@ -2742,6 +2747,8 @@ var externalAbis = {
   [chains.base.id]: {
     },
   [chains.baseSepolia.id]: {
+    },
+  [chains.hyperEvm.id]: {
     }
 });
 ({
@@ -2750,6 +2757,8 @@ var externalAbis = {
   [chains.base.id]: {
     },
   [chains.baseSepolia.id]: {
+    },
+  [chains.hyperEvm.id]: {
     }
 });
 var relayAddress = "0xc81Fd894C0acE037d133aF4886550aC8133568E8";
@@ -2765,6 +2774,10 @@ var addressBook_default = {
   [chains.baseSepolia.id]: {
     address: relayAddress,
     block: 40585325
+  },
+  [chains.hyperEvm.id]: {
+    address: relayAddress,
+    block: 37892152
   }
 };
 var ContractFactory = class {
@@ -2836,24 +2849,98 @@ var ContractFactory = class {
 
 // ../contracts/index.ts
 var supportedChainIds = Object.keys(addressBook_default).map(Number);
+
+// src/calls/index.ts
+var calls_exports = {};
+__export(calls_exports, {
+  MAX_UINT256: () => MAX_UINT256,
+  WAD: () => WAD,
+  ZERO_BYTES32: () => ZERO_BYTES32,
+  approvalCalls: () => approvalCalls,
+  buildLaunchCalls: () => buildLaunchCalls,
+  createCallsApi: () => createCallsApi,
+  encodeStandardLaunchCalls: () => encodeStandardLaunchCalls,
+  encodeZrpLaunchCalls: () => encodeZrpLaunchCalls,
+  serializeCalls: () => serializeCalls,
+  simulateCalls: () => simulateCalls,
+  validateLaunchCallInput: () => validateLaunchCallInput
+});
+
+// src/utils/native.ts
+function shouldUseNative(explicit, config) {
+  return explicit ?? !!config?.defaultUseNative;
+}
+function valueForNative(useNative, amount) {
+  return useNative ? amount : void 0;
+}
+async function simulateCalls(publicClient, calls, opts) {
+  const simulation = await publicClient.simulateCalls({
+    account: opts?.account,
+    calls
+  });
+  if (simulation.results.length !== calls.length) {
+    throw new Error(
+      `Call simulation returned ${simulation.results.length} results for ${calls.length} calls`
+    );
+  }
+  return simulation.results.map((result, index) => {
+    if (!result) {
+      throw new Error(`Call simulation ${index} did not return a result`);
+    }
+    if (result.status === "failure") throw result.error;
+    const call = calls[index];
+    if (!call?.decode) return result.data;
+    return call.decode(result.data);
+  });
+}
+function contractCall(input) {
+  return {
+    to: input.to,
+    data: viem.encodeFunctionData({
+      abi: input.abi,
+      functionName: input.functionName,
+      args: input.args
+    }),
+    value: input.value,
+    decode: (data) => {
+      const result = viem.decodeFunctionResult({
+        abi: input.abi,
+        functionName: input.functionName,
+        data
+      });
+      return input.mapResult ? input.mapResult(result) : result;
+    }
+  };
+}
+function serializeCalls(calls) {
+  return calls.map((call) => ({
+    to: call.to,
+    data: call.data,
+    value: viem.toHex(call.value ?? 0n)
+  }));
+}
+var WAD = 10n ** 18n;
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var DEFAULT_SWAP_FEE_PCT = WAD / 100n;
+var MIN_SWAP_FEE_PCT = 1500000000000000n;
+var MAX_SWAP_FEE_PCT = WAD / 2n;
+var MIN_TOTAL_SUPPLY = 10000n * WAD;
+var MAX_TOTAL_SUPPLY = 20282409603651670423947251286015n;
+var MIN_INVARIANT = 3n * WAD;
 function encodeBaseLaunchCalls(input) {
   return [
-    {
+    contractCall({
       to: input.relay,
-      data: viem.encodeFunctionData({
-        abi: mercuryAbis.bFactory,
-        functionName: "createBToken",
-        args: [input.name, input.symbol, input.totalSupply, input.salt]
-      })
-    },
-    {
+      abi: mercuryAbis.bFactory,
+      functionName: "createBToken",
+      args: [input.name, input.symbol, input.totalSupply, input.salt]
+    }),
+    contractCall({
       to: input.bToken,
-      data: viem.encodeFunctionData({
-        abi: externalAbis.erc20,
-        functionName: "approve",
-        args: [input.relay, input.bTokenApprovalAmount]
-      })
-    }
+      abi: externalAbis.erc20,
+      functionName: "approve",
+      args: [input.relay, input.bTokenApprovalAmount]
+    })
   ];
 }
 function encodeZrpLaunchCalls(input) {
@@ -2862,14 +2949,12 @@ function encodeZrpLaunchCalls(input) {
       ...input,
       bTokenApprovalAmount: input.params.initialPoolBTokens
     }),
-    {
+    contractCall({
       to: input.relay,
-      data: viem.encodeFunctionData({
-        abi: mercuryAbis.bFactory,
-        functionName: "createPoolFromInvariant",
-        args: [input.params]
-      })
-    }
+      abi: mercuryAbis.bFactory,
+      functionName: "createPoolFromInvariant",
+      args: [input.params]
+    })
   ];
 }
 function encodeStandardLaunchCalls(input) {
@@ -2878,36 +2963,81 @@ function encodeStandardLaunchCalls(input) {
       ...input,
       bTokenApprovalAmount: input.params.initialPoolBTokens
     }),
-    {
+    contractCall({
       to: input.reserve,
-      data: viem.encodeFunctionData({
-        abi: externalAbis.erc20,
-        functionName: "approve",
-        args: [input.relay, input.params.initialPoolReserves]
-      })
-    },
-    {
+      abi: externalAbis.erc20,
+      functionName: "approve",
+      args: [input.relay, input.params.initialPoolReserves]
+    }),
+    contractCall({
       to: input.relay,
-      data: viem.encodeFunctionData({
-        abi: mercuryAbis.bFactory,
-        functionName: "createPool",
-        args: [input.params]
-      })
-    }
+      abi: mercuryAbis.bFactory,
+      functionName: "createPool",
+      args: [input.params]
+    })
   ];
 }
-
-// src/launch/constants.ts
-var WAD = 10n ** 18n;
-var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var DEFAULT_SWAP_FEE_PCT = WAD / 100n;
-var MIN_SWAP_FEE_PCT = 1500000000000000n;
-var MAX_SWAP_FEE_PCT = WAD / 2n;
-var MIN_TOTAL_SUPPLY = 10000n * WAD;
-var MAX_TOTAL_SUPPLY = 20282409603651670423947251286015n;
-var MIN_INVARIANT = 3n * WAD;
-
-// src/launch/validate.ts
+function buildLaunchCalls(input) {
+  const salt = normalizeSalt(input.salt);
+  const { mode, swapFeePct, feeRecipient } = resolveLaunchDefaults(input);
+  if (mode === "zrp") {
+    const params2 = {
+      bToken: input.bToken,
+      initialPoolBTokens: input.initialPoolBTokens,
+      reserve: input.reserve,
+      initialInvariant: MIN_INVARIANT,
+      creator: input.creator,
+      feeRecipient,
+      creatorFeePct: input.creatorFeePct,
+      swapFeePct,
+      createHook: true
+    };
+    return encodeZrpLaunchCalls({
+      relay: input.relay,
+      bToken: input.bToken,
+      name: input.name,
+      symbol: input.symbol,
+      totalSupply: input.totalSupply,
+      salt,
+      params: params2
+    });
+  }
+  const initialPoolReserves = input.initialPoolReserves ?? 0n;
+  const circulatingSupply = input.totalSupply - input.initialPoolBTokens;
+  const reservesWad = toWad(initialPoolReserves, input.reserveDecimals ?? 18);
+  const circulatingWad = toWad(circulatingSupply, 18);
+  const bookPrice = divWad(reservesWad, circulatingWad);
+  const params = {
+    bToken: input.bToken,
+    initialPoolBTokens: input.initialPoolBTokens,
+    reserve: input.reserve,
+    initialPoolReserves,
+    initialActivePrice: bookPrice + 1n,
+    initialBLV: 0n,
+    creator: input.creator,
+    feeRecipient,
+    creatorFeePct: input.creatorFeePct,
+    swapFeePct,
+    createHook: true,
+    claimMerkleRoot: ZERO_BYTES32,
+    initialCollateral: 0n,
+    initialDebt: 0n
+  };
+  return encodeStandardLaunchCalls({
+    relay: input.relay,
+    bToken: input.bToken,
+    reserve: input.reserve,
+    name: input.name,
+    symbol: input.symbol,
+    totalSupply: input.totalSupply,
+    salt,
+    params
+  });
+}
+function validateLaunchCallInput(input) {
+  normalizeSalt(input.salt);
+  resolveLaunchDefaults(input);
+}
 function normalizeSalt(salt) {
   if (!salt) return ZERO_BYTES32;
   if (!/^0x[a-fA-F0-9]{64}$/.test(salt)) {
@@ -2915,24 +3045,6 @@ function normalizeSalt(salt) {
   }
   return salt;
 }
-function validateAddress(address, label) {
-  if (!viem.isAddress(address)) throw new Error(`${label} must be a valid address`);
-}
-function validateTokenText(name, symbol) {
-  if (name.trim().length === 0) throw new Error("name is required");
-  if (symbol.trim().length === 0) throw new Error("symbol is required");
-  if (new TextEncoder().encode(name).length > 30) {
-    throw new Error("name exceeds 30 bytes");
-  }
-  if (new TextEncoder().encode(symbol).length > 30) {
-    throw new Error("symbol exceeds 30 bytes");
-  }
-}
-function validateDecimals(decimals, label) {
-  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 18) {
-    throw new Error(`${label} must be an integer between 0 and 18`);
-  }
-}
 function resolveLaunchDefaults(input) {
   const mode = input.mode ?? "zrp";
   if (mode !== "zrp" && mode !== "standard") {
@@ -2982,66 +3094,23 @@ function resolveLaunchDefaults(input) {
   }
   return { mode, swapFeePct, feeRecipient };
 }
-
-// src/launch/calls.ts
-function buildLaunchCalls(input) {
-  const salt = normalizeSalt(input.salt);
-  const { mode, swapFeePct, feeRecipient } = resolveLaunchDefaults(input);
-  if (mode === "zrp") {
-    const params2 = {
-      bToken: input.bToken,
-      initialPoolBTokens: input.initialPoolBTokens,
-      reserve: input.reserve,
-      initialInvariant: MIN_INVARIANT,
-      creator: input.creator,
-      feeRecipient,
-      creatorFeePct: input.creatorFeePct,
-      swapFeePct,
-      createHook: true
-    };
-    return encodeZrpLaunchCalls({
-      relay: input.relay,
-      bToken: input.bToken,
-      name: input.name,
-      symbol: input.symbol,
-      totalSupply: input.totalSupply,
-      salt,
-      params: params2
-    });
+function validateAddress(address, label) {
+  if (!viem.isAddress(address)) throw new Error(`${label} must be a valid address`);
+}
+function validateTokenText(name, symbol) {
+  if (name.trim().length === 0) throw new Error("name is required");
+  if (symbol.trim().length === 0) throw new Error("symbol is required");
+  if (new TextEncoder().encode(name).length > 30) {
+    throw new Error("name exceeds 30 bytes");
+  }
+  if (new TextEncoder().encode(symbol).length > 30) {
+    throw new Error("symbol exceeds 30 bytes");
+  }
+}
+function validateDecimals(decimals, label) {
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 18) {
+    throw new Error(`${label} must be an integer between 0 and 18`);
   }
-  const initialPoolReserves = input.initialPoolReserves ?? 0n;
-  const circulatingSupply = input.totalSupply - input.initialPoolBTokens;
-  const reservesWad = toWad(initialPoolReserves, input.reserveDecimals ?? 18);
-  const circulatingWad = toWad(circulatingSupply, 18);
-  const bookPrice = divWad(reservesWad, circulatingWad);
-  const initialActivePrice = bookPrice + 1n;
-  const initialBLV = 0n;
-  const params = {
-    bToken: input.bToken,
-    initialPoolBTokens: input.initialPoolBTokens,
-    reserve: input.reserve,
-    initialPoolReserves,
-    initialActivePrice,
-    initialBLV,
-    creator: input.creator,
-    feeRecipient,
-    creatorFeePct: input.creatorFeePct,
-    swapFeePct,
-    createHook: true,
-    claimMerkleRoot: ZERO_BYTES32,
-    initialCollateral: 0n,
-    initialDebt: 0n
-  };
-  return encodeStandardLaunchCalls({
-    relay: input.relay,
-    bToken: input.bToken,
-    reserve: input.reserve,
-    name: input.name,
-    symbol: input.symbol,
-    totalSupply: input.totalSupply,
-    salt,
-    params
-  });
 }
 function toWad(amount, decimals) {
   return amount * 10n ** BigInt(18 - decimals);
@@ -3049,9 +3118,157 @@ function toWad(amount, decimals) {
 function divWad(numerator, denominator) {
   return numerator * WAD / denominator;
 }
-function validateLaunchCallInput(input) {
-  normalizeSalt(input.salt);
-  resolveLaunchDefaults(input);
+
+// src/calls/index.ts
+var MAX_UINT256 = 2n ** 256n - 1n;
+function createCallsApi(input) {
+  const relay = () => input.getRelay();
+  return {
+    launch: input.launch,
+    factory: {
+      createBToken: (name, symbol, totalSupply, salt) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bFactory,
+        functionName: "createBToken",
+        args: [name, symbol, totalSupply, salt]
+      }),
+      createPool: (params) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bFactory,
+        functionName: "createPool",
+        args: [params]
+      }),
+      createPoolFromInvariant: (params) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bFactory,
+        functionName: "createPoolFromInvariant",
+        args: [params]
+      })
+    },
+    swap: {
+      buyTokensExactOut: (bToken, amountOut, limitAmount, opts) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bSwap,
+        functionName: "buyTokensExactOut",
+        args: [bToken, amountOut, limitAmount],
+        value: valueForNative(
+          shouldUseNative(opts?.useNative, input.getConfig()),
+          limitAmount
+        )
+      }),
+      buyTokensExactIn: (bToken, amountIn, limitAmount) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bSwap,
+        functionName: "buyTokensExactIn",
+        args: [bToken, amountIn, limitAmount]
+      }),
+      sellTokensExactIn: (bToken, amountIn, limitAmount) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bSwap,
+        functionName: "sellTokensExactIn",
+        args: [bToken, amountIn, limitAmount]
+      }),
+      sellTokensExactOut: (bToken, amountOut, limitAmount) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bSwap,
+        functionName: "sellTokensExactOut",
+        args: [bToken, amountOut, limitAmount]
+      })
+    },
+    staking: {
+      deposit: (bToken, user, amount) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bStaking,
+        functionName: "deposit",
+        args: [bToken, user, amount]
+      }),
+      withdraw: (bToken, amount) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bStaking,
+        functionName: "withdraw",
+        args: [bToken, amount]
+      }),
+      claim: (bToken, user, asNative = false) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bStaking,
+        functionName: "claim",
+        args: [bToken, user, asNative]
+      })
+    },
+    credit: {
+      borrow: (bToken, amount, recipient, opts) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bCredit,
+        functionName: opts?.outputNative ? "borrowNative" : "borrow",
+        args: [bToken, amount, recipient]
+      }),
+      repay: (bToken, reservesIn, recipient, opts) => {
+        const useNative = shouldUseNative(opts?.useNative, input.getConfig());
+        return contractCall({
+          to: relay(),
+          abi: mercuryAbis.bCredit,
+          functionName: useNative ? "repayWithNative" : "repay",
+          args: useNative ? [bToken, recipient] : [bToken, reservesIn, recipient],
+          value: useNative ? reservesIn : void 0
+        });
+      },
+      leverage: (bToken, totalCollateral, collateralIn, maxSwapReservesIn) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bCredit,
+        functionName: "leverage",
+        args: [bToken, totalCollateral, collateralIn, maxSwapReservesIn]
+      }),
+      deleverage: (bToken, collateralToSell, minSwapReservesOut) => contractCall({
+        to: relay(),
+        abi: mercuryAbis.bCredit,
+        functionName: "deleverage",
+        args: [bToken, collateralToSell, minSwapReservesOut],
+        mapResult: ([collateralRedeemed, debtRepaid, refund]) => ({
+          collateralRedeemed,
+          debtRepaid,
+          refund
+        })
+      })
+    },
+    approval: {
+      approve: (token, spender, amount) => contractCall({
+        to: token,
+        abi: externalAbis.erc20,
+        functionName: "approve",
+        args: [spender, amount]
+      }),
+      ensure: async (token, spender, required, opts) => {
+        const owner = opts?.owner ?? input.getAccount();
+        const policy = opts?.policy ?? input.getConfig()?.approvals ?? "infinite";
+        const currentAllowance = await input.getAllowance(
+          token,
+          owner,
+          spender
+        );
+        return approvalCalls({
+          token,
+          spender,
+          required,
+          currentAllowance,
+          policy
+        });
+      }
+    }
+  };
+}
+function approvalCalls(input) {
+  if (input.currentAllowance >= input.required) return [];
+  return [
+    contractCall({
+      to: input.token,
+      abi: externalAbis.erc20,
+      functionName: "approve",
+      args: [
+        input.spender,
+        input.policy === "infinite" ? MAX_UINT256 : input.required
+      ]
+    })
+  ];
 }
 var SDKError = class extends Error {
   kind = "unknown";
@@ -3145,6 +3362,17 @@ async function requireWallet(wallet) {
     });
   return wallet;
 }
+function resolveWriteAccount(wallet, sender) {
+  const walletAccount = wallet.account;
+  if (!walletAccount) return sender;
+  if (walletAccount.address.toLowerCase() !== sender.toLowerCase()) {
+    throw new SDKError(
+      `Wallet account ${walletAccount.address} cannot sign for requested account ${sender}`,
+      { kind: "wallet" }
+    );
+  }
+  return walletAccount;
+}
 async function simulateAndWrite({
   publicClient,
   walletClient,
@@ -3173,7 +3401,82 @@ async function simulateAndWrite({
       account: sender,
       value
     });
-    const hash = await wallet.writeContract(simulation.request);
+    const hash = await wallet.writeContract({
+      ...simulation.request,
+      account: resolveWriteAccount(wallet, sender)
+    });
+    if (confirmations) {
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash,
+        confirmations
+      });
+      if (receipt.status === "reverted") {
+        throw new SDKError("Transaction reverted on-chain", {
+          kind: "reverted",
+          cause: { hash, receipt }
+        });
+      }
+    }
+    return hash;
+  } catch (e) {
+    onSimulateError?.(e);
+    throw classifyTxError(e);
+  }
+}
+async function executeCalls({
+  publicClient,
+  walletClient,
+  calls,
+  account,
+  confirmations,
+  onSimulateError
+}) {
+  const wallet = await requireWallet(walletClient);
+  const sender = account ?? wallet.account?.address;
+  if (!sender) {
+    throw new SDKError(
+      "No account provided and wallet missing default account",
+      {
+        kind: "wallet"
+      }
+    );
+  }
+  if (calls.length === 0) {
+    throw new SDKError("At least one call is required", { kind: "unknown" });
+  }
+  try {
+    const simulation = await publicClient.simulateCalls({
+      account: sender,
+      calls
+    });
+    for (const [index, result] of simulation.results.entries()) {
+      if (!result) {
+        throw new SDKError(`Call simulation ${index} did not return a result`);
+      }
+      if (result.status === "failure") {
+        const error = classifyTxError(result.error);
+        if (error.kind === "unknown" && result.error instanceof Error) {
+          throw new SDKError(result.error.message, {
+            kind: "reverted",
+            cause: result.error
+          });
+        }
+        throw error;
+      }
+    }
+    const { id } = await actions.sendCalls(wallet, {
+      account: resolveWriteAccount(wallet, sender),
+      calls,
+      experimental_fallback: true
+    });
+    const status = await actions.waitForCallsStatus(wallet, {
+      id,
+      throwOnFailure: true
+    });
+    const hash = status.receipts?.[0]?.transactionHash;
+    if (!hash) {
+      throw new SDKError("Calls bundle did not return a transaction hash");
+    }
     if (confirmations) {
       const receipt = await publicClient.waitForTransactionReceipt({
         hash,
@@ -3208,34 +3511,6 @@ async function getAllowance(client, token, owner, spender) {
   });
   return allowance;
 }
-async function ensureAllowance(params) {
-  const current = await getAllowance(
-    params.publicClient,
-    params.token,
-    params.owner,
-    params.spender
-  );
-  if (current >= params.required) return;
-  const amount = params.policy === "infinite" ? 2n ** 256n - 1n : params.required;
-  await simulateAndWrite({
-    publicClient: params.publicClient,
-    walletClient: params.walletClient,
-    address: params.token,
-    abi: externalAbis.erc20,
-    functionName: "approve",
-    args: [params.spender, amount],
-    account: params.owner,
-    confirmations: params.confirmations
-  });
-}
-
-// src/utils/native.ts
-function shouldUseNative(explicit, config) {
-  return explicit ?? !!config?.defaultUseNative;
-}
-function valueForNative(useNative, amount) {
-  return useNative ? amount : void 0;
-}
 
 // src/baseline-sdk.ts
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
@@ -3244,9 +3519,13 @@ var BaselineSDK = class _BaselineSDK {
   walletClient;
   config;
   readFactory;
-  calls = {
+  calls = createCallsApi({
+    getRelay: () => this.proxy,
+    getConfig: () => this.config,
+    getAccount: () => this.getAccount(),
+    getAllowance: (token, owner, spender) => this.getAllowance(token, owner, spender),
     launch: (input, opts) => this.launchCalls(input, opts)
-  };
+  });
   getAccount(opts) {
     const account = opts?.account ?? this.walletClient?.account?.address;
     if (!account) {
@@ -3297,7 +3576,10 @@ var BaselineSDK = class _BaselineSDK {
         account
       });
       const wallet = this.requireWallet();
-      const hash = await wallet.writeContract(request);
+      const hash = await wallet.writeContract({
+        ...request,
+        account: resolveWriteAccount(wallet, account)
+      });
       if (opts?.confirmations)
         await this.publicClient.waitForTransactionReceipt({
           hash,
@@ -3363,7 +3645,7 @@ var BaselineSDK = class _BaselineSDK {
       bToken: "0x0000000000000000000000000000000000000000",
       salt
     });
-    const bToken = await this.precomputeBTokenAddress({
+    const bToken = opts?.precomputedBToken ?? await this.precomputeBTokenAddress({
       name: input.name,
       symbol: input.symbol,
       totalSupply: input.totalSupply,
@@ -3416,18 +3698,22 @@ var BaselineSDK = class _BaselineSDK {
   }
   // ---------- Swap execution ----------
   async buyTokensExactOut(bToken, amountOut, limitAmount, opts) {
-    const useNative = shouldUseNative(opts?.useNative, this.config);
     const account = this.getAccount(opts);
-    const value = valueForNative(useNative, limitAmount);
+    const call = this.calls.swap.buyTokensExactOut(
+      bToken,
+      amountOut,
+      limitAmount,
+      opts
+    );
     return simulateAndWrite({
       publicClient: this.publicClient,
       walletClient: this.walletClient,
-      address: this.proxy,
+      address: call.to,
       abi: mercuryAbis.bSwap,
       functionName: "buyTokensExactOut",
       args: [bToken, amountOut, limitAmount],
       account,
-      value,
+      value: call.value,
       confirmations: opts?.confirmations,
       onSimulateError: opts?.onSimulateError
     });
@@ -3492,23 +3778,20 @@ var BaselineSDK = class _BaselineSDK {
   }
   async withdraw(bToken, amount, opts) {
     const account = this.getAccount(opts);
-    return simulateAndWrite({
+    return executeCalls({
       publicClient: this.publicClient,
       walletClient: this.walletClient,
-      address: this.proxy,
-      abi: mercuryAbis.bStaking,
-      functionName: "withdraw",
-      args: [bToken, amount],
+      calls: [this.calls.staking.withdraw(bToken, amount)],
       account,
       confirmations: opts?.confirmations,
       onSimulateError: opts?.onSimulateError
     });
   }
   async claim(bToken, opts) {
-    const wallet = this.requireWallet();
     const account = this.getAccount(opts);
     const user = opts?.user ?? account;
     const asNative = opts?.asNative ?? false;
+    const wallet = this.requireWallet();
     try {
       const { result, request } = await this.publicClient.simulateContract({
         address: this.proxy,
@@ -3517,7 +3800,10 @@ var BaselineSDK = class _BaselineSDK {
         args: [bToken, user, asNative],
         account
       });
-      const hash = await wallet.writeContract(request);
+      const hash = await wallet.writeContract({
+        ...request,
+        account: resolveWriteAccount(wallet, account)
+      });
       if (opts?.confirmations)
         await this.publicClient.waitForTransactionReceipt({
           hash,
@@ -3568,13 +3854,12 @@ var BaselineSDK = class _BaselineSDK {
   }
   async borrow(bToken, amount, recipient, opts) {
     const account = this.getAccount(opts);
-    const functionName = opts?.outputNative ? "borrowNative" : "borrow";
     return simulateAndWrite({
       publicClient: this.publicClient,
       walletClient: this.walletClient,
       address: this.proxy,
       abi: mercuryAbis.bCredit,
-      functionName,
+      functionName: opts?.outputNative ? "borrowNative" : "borrow",
       args: [bToken, amount, recipient],
       account,
       confirmations: opts?.confirmations,
@@ -3582,20 +3867,18 @@ var BaselineSDK = class _BaselineSDK {
     });
   }
   async repay(bToken, reservesIn, recipient, opts) {
-    const useNative = shouldUseNative(opts?.useNative, this.config);
     const account = this.getAccount(opts);
-    const functionName = useNative ? "repayWithNative" : "repay";
-    const args = useNative ? [bToken, recipient] : [bToken, reservesIn, recipient];
-    const value = valueForNative(useNative, reservesIn);
+    const call = this.calls.credit.repay(bToken, reservesIn, recipient, opts);
+    const useNative = shouldUseNative(opts?.useNative, this.config);
     return simulateAndWrite({
       publicClient: this.publicClient,
       walletClient: this.walletClient,
-      address: this.proxy,
+      address: call.to,
       abi: mercuryAbis.bCredit,
-      functionName,
-      args,
+      functionName: useNative ? "repayWithNative" : "repay",
+      args: useNative ? [bToken, recipient] : [bToken, reservesIn, recipient],
       account,
-      value,
+      value: call.value,
       confirmations: opts?.confirmations,
       onSimulateError: opts?.onSimulateError
     });
@@ -3684,6 +3967,15 @@ var BaselineSDK = class _BaselineSDK {
       userAccumulator
     };
   }
+  async getEarned(bToken, user) {
+    const earned = await this.publicClient.readContract({
+      address: this.proxy,
+      abi: mercuryAbis.bStaking,
+      functionName: "getEarned",
+      args: [bToken, user]
+    });
+    return earned;
+  }
   async getCreditAccount(bToken, user) {
     const [collateral, debt] = await this.publicClient.readContract({
       address: this.proxy,
@@ -3723,21 +4015,17 @@ var BaselineSDK = class _BaselineSDK {
   async ensureApproval(token, spender, required, opts) {
     const account = this.getAccount(opts);
     const policy = opts?.policy ?? this.config?.approvals ?? "infinite";
-    await ensureAllowance({
-      publicClient: this.publicClient,
-      walletClient: this.walletClient,
-      token,
+    const calls = await this.calls.approval.ensure(token, spender, required, {
       owner: account,
-      spender,
-      required,
-      policy,
-      confirmations: opts?.confirmations
+      policy
     });
+    const [call] = calls;
+    if (!call) return;
+    const amount = policy === "infinite" ? 2n ** 256n - 1n : required;
+    await this.approve(token, spender, amount, opts);
   }
   // ---------- Lens queries ----------
   async getBTokenInfo(bToken) {
-    const bytecode = await this.publicClient.getBytecode({ address: bToken });
-    const hasBytecode = !!bytecode && bytecode !== "0x";
     const results = await this.publicClient.multicall({
       allowFailure: true,
       contracts: [
@@ -3824,14 +4112,10 @@ var BaselineSDK = class _BaselineSDK {
     const reserveDecimals = normalizeQuoteState(
       result(12)
     )?.reserveDecimals;
-    const hasBaselineState = reserve !== void 0 && reserve.toLowerCase() !== ZERO_ADDRESS && maker !== void 0;
-    const status = !hasBytecode ? "not_deployed" : !hasBaselineState ? "contract_only" : maker.initialized ? "initialized" : "baseline_uninitialized";
     return {
       chainId: this.chainId,
       relay: this.proxy,
       bToken,
-      status,
-      bytecode: hasBytecode,
       name,
       symbol,
       decimals,
@@ -3847,6 +4131,15 @@ var BaselineSDK = class _BaselineSDK {
       maker
     };
   }
+  async getBTokenStatus(bToken, info) {
+    const bytecode = await this.publicClient.getCode({ address: bToken });
+    const hasBytecode = !!bytecode && bytecode !== "0x";
+    const tokenInfo = info ?? await this.getBTokenInfo(bToken);
+    const hasBaselineState = tokenInfo.reserve !== void 0 && tokenInfo.reserve.toLowerCase() !== ZERO_ADDRESS && tokenInfo.maker !== void 0;
+    const maker = tokenInfo.maker;
+    const status = !hasBytecode ? "not_deployed" : !hasBaselineState ? "contract_only" : maker?.initialized ? "initialized" : "baseline_uninitialized";
+    return { status, bytecode: hasBytecode };
+  }
   async getReserve(bToken) {
     const reserve = await this.publicClient.readContract({
       address: this.proxy,
@@ -3908,16 +4201,29 @@ function normalizeQuoteState(value) {
   const reserveDecimals = Array.isArray(value) ? value[6] : value.reserveDecimals;
   return typeof reserveDecimals === "number" ? { reserveDecimals } : void 0;
 }
-function serializeCalls(calls) {
-  return calls.map((call) => ({
-    to: call.to,
-    data: call.data,
-    value: viem.toHex(call.value ?? 0n)
-  }));
+
+// src/utils/slippage.ts
+function maxInWithSlippage(amountIn, slippageBps) {
+  if (slippageBps < 0) throw new Error("slippageBps must be >= 0");
+  return amountIn * BigInt(1e4 + slippageBps) / 10000n;
 }
+function minOutWithSlippage(amountOut, slippageBps) {
+  if (slippageBps < 0) throw new Error("slippageBps must be >= 0");
+  const numerator = amountOut * 10000n;
+  const denom = BigInt(1e4 + slippageBps);
+  return numerator / denom;
+}
+
+// index.ts
+var abis = mercuryAbis;
+var supportedChainIds2 = supportedChainIds;
 
 exports.BaselineSDK = BaselineSDK;
 exports.SDKError = SDKError;
-exports.abis = mercuryAbis;
+exports.abis = abis;
+exports.calls = calls_exports;
+exports.maxInWithSlippage = maxInWithSlippage;
+exports.minOutWithSlippage = minOutWithSlippage;
 exports.serializeCalls = serializeCalls;
-exports.supportedChainIds = supportedChainIds;
+exports.simulateCalls = simulateCalls;
+exports.supportedChainIds = supportedChainIds2;