@baseline-markets/cli 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Cli } from "incur";
+import { Cli as Cli2 } from "incur";
+import { pathToFileURL } from "node:url";
 
 // src/commands/info.ts
 import { BaselineSDK } from "@baseline-markets/sdk";
@@ -12,6 +13,8 @@ import {
   arbitrum as arbitrumMainnet,
   base as baseMainnet,
   baseSepolia as baseTestnet,
+  hyperEvm,
+  hyperliquidEvmTestnet,
   mainnet as ethereumMainnet
 } from "viem/chains";
 var chains = {
@@ -74,6 +77,32 @@ var chains = {
         ]
       }
     }
+  }),
+  hyperevm: defineChain({
+    ...hyperEvm,
+    rpcUrls: {
+      default: {
+        http: ["https://wispy-hidden-knowledge.hype-mainnet.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471/nanoreth"]
+      }
+    },
+    contracts: {
+      multicall3: {
+        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
+      }
+    }
+  }),
+  hyperevmTestnet: defineChain({
+    ...hyperliquidEvmTestnet,
+    rpcUrls: {
+      default: {
+        http: ["https://wispy-hidden-knowledge.hype-testnet.quiknode.pro/744cca7e0d6ab60a5bff9c19aee2599dbff70471/nanoreth"]
+      }
+    },
+    contracts: {
+      multicall3: {
+        address: "0xcA11bde05977b3631167028862bE2a173976CA11"
+      }
+    }
   })
 };
 var chains_default = chains;
@@ -133,7 +162,8 @@ var infoCommand = {
       transport: http(c.options.rpcUrl)
     }));
     const info = await sdk.getBTokenInfo(token);
-    return serializeBTokenInfo(info, buildTokenLinks(chain, info.bToken));
+    const status = await sdk.getBTokenStatus(token, info);
+    return serializeBTokenInfo({ ...info, ...status }, buildTokenLinks(chain, info.bToken));
   }
 };
 function serializeBTokenInfo(info, links) {
@@ -207,6 +237,7 @@ import {
   createWalletClient,
   http as http2
 } from "viem";
+import { sendCalls, waitForCallsStatus } from "viem/actions";
 import { privateKeyToAccount } from "viem/accounts";
 function parsePrivateKey(value) {
   if (!/^0x[0-9a-fA-F]{64}$/.test(value)) {
@@ -214,18 +245,6 @@ function parsePrivateKey(value) {
   }
   return value;
 }
-async function estimateCallGas(estimate, retryDelayMs = 1000) {
-  let lastError;
-  for (let attempt = 0;attempt < 5; attempt++) {
-    try {
-      return await estimate();
-    } catch (error) {
-      lastError = error;
-      await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
-    }
-  }
-  throw lastError;
-}
 async function executeCalls(input) {
   const account = privateKeyToAccount(input.privateKey);
   if (input.expectedAccount && account.address.toLowerCase() !== input.expectedAccount.toLowerCase()) {
@@ -238,35 +257,52 @@ async function executeCalls(input) {
     chain: input.chain,
     transport
   });
-  const transactions = [];
-  for (const [index, call] of input.calls.entries()) {
-    const gas = await estimateCallGas(() => publicClient.estimateGas({
-      account: account.address,
-      to: call.to,
-      data: call.data,
-      value: call.value ?? 0n
-    })) + 50000n;
-    const hash = await walletClient.sendTransaction({
-      account,
-      chain: input.chain,
-      to: call.to,
-      data: call.data,
-      value: call.value ?? 0n,
-      gas
-    });
-    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const { id } = await sendCalls(walletClient, {
+    account,
+    chain: input.chain,
+    calls: input.calls,
+    experimental_fallback: true
+  });
+  const status = await waitForCallsStatus(walletClient, {
+    id,
+    throwOnFailure: false
+  });
+  const bundles = [{ id, atomic: status.atomic }];
+  const receipts = status.receipts ?? [];
+  if (status.status === "failure") {
+    throw new Error("Calls bundle failed.");
+  }
+  if (receipts.length === 0) {
+    throw new Error("Calls bundle did not return any transaction receipts.");
+  }
+  const transactions = receipts.map((receipt, index) => {
+    if (!receipt.transactionHash) {
+      throw new Error(`Receipt ${index} did not return a transaction hash.`);
+    }
     if (receipt.status !== "success") {
-      throw new Error(`Transaction ${index} reverted: ${hash}`);
+      throw new Error(`Transaction ${index} reverted: ${receipt.transactionHash}`);
     }
-    transactions.push({
+    return {
       index,
-      hash,
+      hash: receipt.transactionHash,
       status: receipt.status,
       blockNumber: receipt.blockNumber.toString(),
       gasUsed: receipt.gasUsed.toString()
-    });
+    };
+  });
+  if (input.confirmations) {
+    const uniqueHashes = [...new Set(transactions.map((tx) => tx.hash))];
+    for (const [index, hash] of uniqueHashes.entries()) {
+      const confirmed = await publicClient.waitForTransactionReceipt({
+        hash,
+        confirmations: input.confirmations
+      });
+      if (confirmed.status !== "success") {
+        throw new Error(`Transaction ${index} reverted: ${hash}`);
+      }
+    }
   }
-  return { transactions };
+  return { bundles, transactions };
 }
 
 // src/commands/launch.ts
@@ -346,12 +382,18 @@ async function buildLaunchArtifact(options) {
     salt,
     deployer: account
   });
-  const calls = await sdk.calls.launch(launchInput, { account });
+  const calls = await sdk.calls.launch(launchInput, {
+    account,
+    precomputedBToken: bToken
+  });
+  const links = buildTokenLinks(chain, bToken);
   return {
     chainId: options.chainId,
     chain: chain.name,
     account,
     bToken,
+    appUrl: links.appUrl,
+    explorerUrl: links.explorerUrl,
     calls
   };
 }
@@ -407,6 +449,955 @@ async function executeLaunchArtifact(artifact, options) {
   });
 }
 
+// src/commands/quote.ts
+import { Cli } from "incur";
+
+// src/commands/swap.ts
+import {
+  maxInWithSlippage,
+  minOutWithSlippage,
+  serializeCalls as serializeCalls2,
+  simulateCalls
+} from "@baseline-markets/sdk";
+import { z as z5 } from "incur";
+
+// src/commands/client.ts
+import { BaselineSDK as BaselineSDK3 } from "@baseline-markets/sdk";
+import { z as z4 } from "incur";
+import {
+  createPublicClient as createPublicClient4,
+  createWalletClient as createWalletClient2,
+  formatUnits as formatUnits2,
+  http as http4,
+  parseUnits as parseUnits2
+} from "viem";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+var chainOptions = {
+  chainId: z4.coerce.number().default(chains_default.baseSepolia.id).describe("Chain ID."),
+  rpcUrl: z4.string().optional().describe("RPC URL.")
+};
+var signerOptions = {
+  privateKey: z4.string().optional().describe("Private key. Falls back to BASELINE_PRIVATE_KEY."),
+  confirmations: z4.coerce.number().int().nonnegative().default(1).describe("Confirmations to wait for after each transaction.")
+};
+function createReadSdk(options) {
+  const chain = getChain(options.chainId);
+  const publicClient = createPublicClient4({
+    chain,
+    transport: http4(options.rpcUrl)
+  });
+  return { chain, publicClient, sdk: new BaselineSDK3(publicClient) };
+}
+function createWalletSdk(options) {
+  const privateKey = options.privateKey ?? process.env.BASELINE_PRIVATE_KEY;
+  if (!privateKey)
+    throw missingPrivateKeyError();
+  const chain = getChain(options.chainId);
+  const account = privateKeyToAccount3(parsePrivateKey(privateKey));
+  const transport = http4(options.rpcUrl);
+  const publicClient = createPublicClient4({ chain, transport });
+  const walletClient = createWalletClient2({
+    account,
+    chain,
+    transport
+  });
+  return {
+    account,
+    chain,
+    publicClient,
+    walletClient,
+    sdk: new BaselineSDK3(publicClient, walletClient)
+  };
+}
+function resolvePrivateKey(value) {
+  const privateKey = value ?? process.env.BASELINE_PRIVATE_KEY;
+  if (!privateKey)
+    throw missingPrivateKeyError();
+  return parsePrivateKey(privateKey);
+}
+function missingPrivateKeyError() {
+  return new Error("--private-key or BASELINE_PRIVATE_KEY is required.");
+}
+function parseTokenUnits(amount, decimals) {
+  return parseUnits2(amount, decimals);
+}
+function formatTokenUnits(amount, decimals) {
+  const formatted = formatUnits2(amount, decimals);
+  return formatted.includes(".") ? formatted.replace(/\.?0+$/, "") : formatted;
+}
+function serializeAmount(amount, decimals) {
+  return {
+    raw: amount.toString(),
+    formatted: formatTokenUnits(amount, decimals),
+    decimals
+  };
+}
+function serializeTransaction(hash) {
+  return { hash };
+}
+function chainName(chain) {
+  return chain.name;
+}
+function normalizeUser(user, fallback) {
+  return user ?? fallback;
+}
+
+// src/commands/swap.ts
+var slippageBps = z5.coerce.number().int().min(0).max(1e4).default(100).describe("Slippage tolerance in basis points.");
+var swapModeOptions = {
+  buy: z5.boolean().default(false).describe("Buy BTokens."),
+  sell: z5.boolean().default(false).describe("Sell BTokens."),
+  exactIn: z5.boolean().default(false).describe("Treat --amount as the exact input amount. This is the default."),
+  exactOut: z5.boolean().default(false).describe("Treat --amount as the exact output amount.")
+};
+var quoteOptions = z5.object({
+  ...chainOptions,
+  token: address("token").describe("Baseline token address."),
+  ...swapModeOptions,
+  amount: z5.string().describe("Amount in token units."),
+  bTokenDecimals: z5.coerce.number().int().min(0).max(36).optional().describe("BToken decimals. Defaults to token metadata."),
+  reserveDecimals: z5.coerce.number().int().min(0).max(36).optional().describe("Reserve token decimals. Defaults to token metadata.")
+});
+var executeOptions = quoteOptions.extend({
+  ...signerOptions,
+  slippageBps,
+  simulate: z5.boolean().default(false).describe("Simulate the exact swap calls without sending them."),
+  approval: z5.enum(["infinite", "exact"]).default("infinite").describe("ERC20 approval amount for the input token.")
+});
+var swapCommand = {
+  description: "Quote and execute Baseline swaps.",
+  options: executeOptions,
+  run: ({ options }) => runSwap(options)
+};
+var swapQuoteCommand = {
+  description: "Quote a Baseline swap.",
+  options: quoteOptions,
+  run: ({ options }) => buildSwapQuote(options)
+};
+async function buildSwapQuote(options) {
+  const mode = normalizeSwapOptions(options);
+  const { chain, sdk } = createReadSdk(options);
+  const info = await sdk.getBTokenInfo(options.token);
+  const decimals = resolveSwapDecimals(mode, info);
+  const amount = parseSwapAmount(mode, decimals);
+  const quote = await readQuote(mode, sdk, amount);
+  return serializeSwapQuote({
+    chainId: chain.id,
+    chain: chainName(chain),
+    token: options.token,
+    reserve: info.reserve,
+    side: mode.side,
+    exact: mode.exact,
+    amount,
+    quote,
+    decimals,
+    slippageBps: 0,
+    limitAmount: undefined
+  });
+}
+async function runSwap(options) {
+  const mode = normalizeSwapOptions(options);
+  const { chain, publicClient, sdk, account } = createWalletSdk(options);
+  const info = await sdk.getBTokenInfo(options.token);
+  if (!info.reserve)
+    throw new Error("Token reserve is unavailable.");
+  const decimals = resolveSwapDecimals(mode, info);
+  const amount = parseSwapAmount(mode, decimals);
+  const quote = await readQuote(mode, sdk, amount);
+  const limitAmount = computeLimitAmount(quote, options.slippageBps);
+  const input = inputApproval(mode, info.reserve, amount, limitAmount, decimals);
+  const calls = [
+    ...await sdk.calls.approval.ensure(input.token, sdk.proxy, input.amount, {
+      owner: account.address,
+      policy: options.approval
+    }),
+    writeSwapCall(mode, sdk, amount, limitAmount)
+  ];
+  const serializedQuote = serializeSwapQuote({
+    chainId: chain.id,
+    chain: chainName(chain),
+    token: options.token,
+    reserve: info.reserve,
+    side: mode.side,
+    exact: mode.exact,
+    amount,
+    quote,
+    decimals,
+    slippageBps: options.slippageBps,
+    limitAmount
+  });
+  if (options.simulate) {
+    const simulation = await simulateCalls(publicClient, calls, {
+      account: account.address
+    });
+    return {
+      ...serializedQuote,
+      account: account.address,
+      inputApproval: {
+        token: input.token,
+        amount: serializeAmount(input.amount, input.decimals)
+      },
+      calls: serializeCalls2(calls),
+      simulation
+    };
+  }
+  const execution = await executeCalls({
+    chain,
+    calls,
+    privateKey: resolvePrivateKey(options.privateKey),
+    rpcUrl: options.rpcUrl,
+    expectedAccount: account.address,
+    confirmations: options.confirmations
+  });
+  const lastTransaction = execution.transactions.at(-1);
+  if (!lastTransaction)
+    throw new Error("Swap execution produced no transaction.");
+  return {
+    ...serializedQuote,
+    account: account.address,
+    inputApproval: {
+      token: input.token,
+      amount: serializeAmount(input.amount, input.decimals)
+    },
+    calls: serializeCalls2(calls),
+    execution,
+    transaction: serializeTransaction(lastTransaction.hash)
+  };
+}
+function resolveSwapDecimals(options, info) {
+  return {
+    bToken: options.bTokenDecimals ?? info.decimals ?? 18,
+    reserve: options.reserveDecimals ?? info.reserveDecimals ?? 18
+  };
+}
+function parseSwapAmount(options, decimals) {
+  return parseTokenUnits(options.amount, amountDenomination(options, decimals));
+}
+function amountDenomination(options, decimals) {
+  if (options.side === "buy") {
+    return options.exact === "in" ? decimals.reserve : decimals.bToken;
+  }
+  return options.exact === "in" ? decimals.bToken : decimals.reserve;
+}
+async function readQuote(options, sdk, amount) {
+  if (options.side === "buy") {
+    if (options.exact === "in") {
+      return {
+        kind: "buy-exact-in",
+        ...await sdk.quoteBuyExactIn(options.token, amount)
+      };
+    }
+    return {
+      kind: "buy-exact-out",
+      ...await sdk.quoteBuyExactOut(options.token, amount)
+    };
+  }
+  if (options.exact === "in") {
+    return {
+      kind: "sell-exact-in",
+      ...await sdk.quoteSellExactIn(options.token, amount)
+    };
+  }
+  return {
+    kind: "sell-exact-out",
+    ...await sdk.quoteSellExactOut(options.token, amount)
+  };
+}
+function computeLimitAmount(quote, slippageBps2) {
+  switch (quote.kind) {
+    case "buy-exact-in":
+      return minOut(quote.tokensOut, slippageBps2);
+    case "buy-exact-out":
+      return maxIn(quote.amountIn, slippageBps2);
+    case "sell-exact-in":
+      return minOut(quote.amountOut, slippageBps2);
+    case "sell-exact-out":
+      return maxIn(quote.tokensIn, slippageBps2);
+  }
+}
+function inputApproval(options, reserve, amount, limitAmount, decimals) {
+  if (options.side === "buy") {
+    return {
+      token: reserve,
+      amount: options.exact === "in" ? amount : limitAmount,
+      decimals: decimals.reserve
+    };
+  }
+  return {
+    token: options.token,
+    amount: options.exact === "in" ? amount : limitAmount,
+    decimals: decimals.bToken
+  };
+}
+function writeSwapCall(options, sdk, amount, limitAmount) {
+  if (options.side === "buy") {
+    return options.exact === "in" ? sdk.calls.swap.buyTokensExactIn(options.token, amount, limitAmount) : sdk.calls.swap.buyTokensExactOut(options.token, amount, limitAmount);
+  }
+  return options.exact === "in" ? sdk.calls.swap.sellTokensExactIn(options.token, amount, limitAmount) : sdk.calls.swap.sellTokensExactOut(options.token, amount, limitAmount);
+}
+function serializeSwapQuote(input) {
+  return {
+    chainId: input.chainId,
+    chain: input.chain,
+    token: input.token,
+    reserve: input.reserve,
+    side: input.side,
+    exact: input.exact,
+    amount: serializeAmount(input.amount, amountDenomination(input, input.decimals)),
+    quote: serializeQuote(input),
+    slippageBps: input.slippageBps,
+    limitAmount: input.limitAmount !== undefined ? serializeAmount(input.limitAmount, limitDenomination(input, input.decimals)) : undefined
+  };
+}
+function serializeQuote(input) {
+  const fee = serializeAmount(input.quote.fee, input.decimals.reserve);
+  const slippage = input.quote.slippage.toString();
+  switch (input.quote.kind) {
+    case "buy-exact-in":
+      return {
+        tokensOut: serializeAmount(input.quote.tokensOut, input.decimals.bToken),
+        fee,
+        slippage
+      };
+    case "buy-exact-out":
+      return {
+        amountIn: serializeAmount(input.quote.amountIn, input.decimals.reserve),
+        fee,
+        slippage
+      };
+    case "sell-exact-in":
+      return {
+        amountOut: serializeAmount(input.quote.amountOut, input.decimals.reserve),
+        fee,
+        slippage
+      };
+    case "sell-exact-out":
+      return {
+        tokensIn: serializeAmount(input.quote.tokensIn, input.decimals.bToken),
+        fee,
+        slippage
+      };
+  }
+}
+function limitDenomination(options, decimals) {
+  if (options.side === "buy") {
+    return options.exact === "in" ? decimals.bToken : decimals.reserve;
+  }
+  return options.exact === "in" ? decimals.reserve : decimals.bToken;
+}
+function minOut(amount, bps) {
+  return minOutWithSlippage(amount, bps);
+}
+function maxIn(amount, bps) {
+  return maxInWithSlippage(amount, bps);
+}
+function normalizeSwapOptions(options) {
+  if (options.buy === options.sell) {
+    throw new Error("Specify exactly one of --buy or --sell.");
+  }
+  if (options.exactIn && options.exactOut) {
+    throw new Error("Specify only one of --exact-in or --exact-out.");
+  }
+  const { buy, sell, exactIn, exactOut, ...rest } = options;
+  return {
+    ...rest,
+    side: options.buy ? "buy" : "sell",
+    exact: exactOut ? "out" : "in"
+  };
+}
+
+// src/commands/quote.ts
+var quoteCommand = Cli.create("quote", {
+  description: "Quote Baseline actions."
+}).command("swap", swapQuoteCommand);
+
+// src/commands/position/options.ts
+import { z as z6 } from "incur";
+var tokenOptions = {
+  token: address("token").describe("Baseline token address."),
+  bTokenDecimals: z6.coerce.number().int().min(0).max(36).optional().describe("BToken decimals. Defaults to token metadata."),
+  reserveDecimals: z6.coerce.number().int().min(0).max(36).optional().describe("Reserve decimals. Defaults to token metadata.")
+};
+var accountOptions = z6.object({
+  ...chainOptions,
+  ...tokenOptions,
+  user: address("user").describe("User address.")
+});
+var stakeOptions = z6.object({
+  ...chainOptions,
+  ...signerOptions,
+  ...tokenOptions,
+  amount: z6.string().describe("BToken amount to stake."),
+  user: address("user").optional().describe("Stake recipient. Defaults to signer."),
+  approval: z6.enum(["infinite", "exact"]).default("infinite").describe("ERC20 approval amount for BToken staking."),
+  simulate: z6.boolean().default(false).describe("Simulate the exact stake calls without sending them.")
+});
+var unstakeOptions = z6.object({
+  ...chainOptions,
+  ...signerOptions,
+  ...tokenOptions,
+  amount: z6.string().describe("Staked BToken amount to withdraw."),
+  simulate: z6.boolean().default(false).describe("Simulate the exact unstake calls without sending them.")
+});
+var claimOptions = z6.object({
+  ...chainOptions,
+  ...signerOptions,
+  ...tokenOptions,
+  user: address("user").optional().describe("Reward recipient. Defaults to signer."),
+  asNative: z6.boolean().default(false).describe("Claim wrapped-native rewards as native ETH when supported."),
+  simulate: z6.boolean().default(false).describe("Simulate the exact claim calls without sending them.")
+});
+var borrowOptions = z6.object({
+  ...chainOptions,
+  ...signerOptions,
+  ...tokenOptions,
+  amount: z6.string().describe("Reserve amount to borrow."),
+  recipient: address("recipient").optional().describe("Reserve recipient. Defaults to signer."),
+  outputNative: z6.boolean().default(false).describe("Receive wrapped-native reserves as native ETH when supported."),
+  simulate: z6.boolean().default(false).describe("Simulate the exact borrow calls without sending them.")
+});
+var repayOptions = z6.object({
+  ...chainOptions,
+  ...signerOptions,
+  ...tokenOptions,
+  amount: z6.string().describe("Reserve amount to repay."),
+  recipient: address("recipient").optional().describe("Credit account to repay. Defaults to signer."),
+  useNative: z6.boolean().default(false).describe("Repay wrapped-native reserves with native ETH when supported."),
+  approval: z6.enum(["infinite", "exact"]).default("infinite").describe("ERC20 approval amount for reserve repayment."),
+  simulate: z6.boolean().default(false).describe("Simulate the exact repay calls without sending them.")
+});
+
+// src/commands/position/read.ts
+import { abis } from "@baseline-markets/sdk";
+import { BaseError, ContractFunctionRevertedError, erc20Abi } from "viem";
+async function readPosition(options) {
+  const { chain, publicClient, sdk } = createReadSdk(options);
+  const info = await sdk.getBTokenInfo(options.token);
+  const snapshot = await readPositionSnapshot({
+    publicClient,
+    proxy: sdk.proxy,
+    token: options.token,
+    user: options.user,
+    reserve: info.reserve
+  });
+  return serializePosition({
+    chainId: chain.id,
+    chain: chainName(chain),
+    token: options.token,
+    name: info.name,
+    symbol: info.symbol,
+    reserve: info.reserve,
+    reserveSymbol: snapshot.reserveSymbol,
+    user: options.user,
+    account: snapshot.account,
+    creditAccount: snapshot.creditAccount,
+    maxBorrow: snapshot.maxBorrow,
+    earned: snapshot.earned,
+    bTokenDecimals: options.bTokenDecimals ?? info.decimals ?? 18,
+    reserveDecimals: options.reserveDecimals ?? info.reserveDecimals ?? 18
+  });
+}
+async function readPositionSnapshot(input) {
+  const contracts = [
+    {
+      address: input.proxy,
+      abi: abis.bLens,
+      functionName: "stakedPosition",
+      args: [input.token, input.user]
+    },
+    {
+      address: input.proxy,
+      abi: abis.bLens,
+      functionName: "creditAccount",
+      args: [input.token, input.user]
+    },
+    {
+      address: input.proxy,
+      abi: abis.bCredit,
+      functionName: "getMaxBorrow",
+      args: [input.token, input.user]
+    },
+    {
+      address: input.proxy,
+      abi: abis.bStaking,
+      functionName: "getEarned",
+      args: [input.token, input.user]
+    },
+    ...input.reserve ? [
+      {
+        address: input.reserve,
+        abi: erc20Abi,
+        functionName: "symbol"
+      }
+    ] : []
+  ];
+  const results = await input.publicClient.multicall({
+    allowFailure: true,
+    contracts
+  });
+  const staked = requiredResult(results[0], "staked position");
+  const credit = requiredResult(results[1], "credit account");
+  const maxBorrow = results[2]?.status === "success" ? results[2].result : 0n;
+  const earned = requiredResult(results[3], "earned rewards");
+  const reserveSymbol = results[4]?.status === "success" ? results[4].result : undefined;
+  return {
+    account: {
+      amount: staked[0],
+      locked: staked[1],
+      earned: staked[2],
+      userAccumulator: staked[3]
+    },
+    creditAccount: {
+      collateral: credit[0],
+      debt: credit[1]
+    },
+    maxBorrow,
+    earned,
+    reserveSymbol
+  };
+}
+function requiredResult(result, label) {
+  if (result?.status === "success")
+    return result.result;
+  throw new Error(`Failed to read ${label}.`);
+}
+function formatPosition(position) {
+  const symbol = position.symbol ?? "BTokens";
+  const reserveUnit = position.reserveSymbol ?? position.reserve ?? "reserve";
+  const title = position.name ? position.symbol ? `${position.name} (${position.symbol})` : position.name : position.symbol ? position.symbol : "Position";
+  return [
+    title,
+    `Chain: ${position.chain} (${position.chainId})`,
+    `Token: ${position.token}`,
+    `User: ${position.user}`,
+    "",
+    table([
+      ["Total staked", position.amount.formatted, symbol],
+      ["Claimable", position.earned.formatted, reserveUnit],
+      ["Collateral", position.collateral.formatted, symbol],
+      ["Debt", position.debt.formatted, reserveUnit],
+      ["Max borrow", position.maxBorrow.formatted, reserveUnit]
+    ])
+  ].join(`
+`);
+}
+async function readMaxBorrow(sdk, token, user) {
+  try {
+    return await sdk.getMaxBorrow(token, user);
+  } catch (error) {
+    if (error instanceof BaseError && error.walk((cause) => cause instanceof ContractFunctionRevertedError)) {
+      return 0n;
+    }
+    throw error;
+  }
+}
+function serializePosition(input) {
+  return {
+    chainId: input.chainId,
+    chain: input.chain,
+    token: input.token,
+    name: input.name,
+    symbol: input.symbol,
+    reserve: input.reserve,
+    reserveSymbol: input.reserveSymbol,
+    user: input.user,
+    amount: serializeAmount(input.account.amount, input.bTokenDecimals),
+    locked: serializeAmount(input.account.locked, input.bTokenDecimals),
+    unlocked: serializeAmount(input.account.amount - input.account.locked, input.bTokenDecimals),
+    earned: serializeAmount(input.earned ?? input.account.earned, input.reserveDecimals),
+    collateral: serializeAmount(input.creditAccount.collateral, input.bTokenDecimals),
+    debt: serializeAmount(input.creditAccount.debt, input.reserveDecimals),
+    maxBorrow: serializeAmount(input.maxBorrow, input.reserveDecimals),
+    storedEarned: serializeAmount(input.account.earned, input.reserveDecimals),
+    userAccumulator: input.account.userAccumulator.toString()
+  };
+}
+function table(rows) {
+  const labelWidth = Math.max(...rows.map(([label]) => label.length), 5);
+  const amountWidth = Math.max(...rows.map(([, amount]) => amount.length), 6);
+  const unitWidth = Math.max(...rows.map(([, , unit]) => unit.length), 4);
+  const line = `| ${"-".repeat(labelWidth)} | ${"-".repeat(amountWidth)} | ${"-".repeat(unitWidth)} |`;
+  return [
+    `| ${"Metric".padEnd(labelWidth)} | ${"Amount".padStart(amountWidth)} | ${"Unit".padEnd(unitWidth)} |`,
+    line,
+    ...rows.map(([label, amount, unit]) => `| ${label.padEnd(labelWidth)} | ${amount.padStart(amountWidth)} | ${unit.padEnd(unitWidth)} |`)
+  ].join(`
+`);
+}
+
+// src/commands/position/tx.ts
+import { serializeCalls as serializeCalls3, simulateCalls as simulateCalls2 } from "@baseline-markets/sdk";
+async function simulatePositionCalls(publicClient, calls, account) {
+  return {
+    calls: serializeCalls3(calls),
+    simulation: await simulateCalls2(publicClient, calls, {
+      account
+    })
+  };
+}
+async function executePositionCalls(input) {
+  const execution = await executeCalls({
+    chain: input.chain,
+    calls: input.calls,
+    privateKey: input.privateKey,
+    rpcUrl: input.rpcUrl,
+    expectedAccount: input.account,
+    confirmations: input.confirmations
+  });
+  const lastTransaction = execution.transactions.at(-1);
+  if (!lastTransaction) {
+    throw new Error(`Position ${input.action} produced no transaction.`);
+  }
+  return {
+    calls: serializeCalls3(input.calls),
+    execution,
+    transaction: serializeTransaction(lastTransaction.hash)
+  };
+}
+
+// src/commands/position/actions.ts
+async function stakePosition(options) {
+  const { chain, publicClient, sdk, account } = createWalletSdk(options);
+  const info = await sdk.getBTokenInfo(options.token);
+  const bTokenDecimals = options.bTokenDecimals ?? info.decimals ?? 18;
+  const reserveDecimals = options.reserveDecimals ?? info.reserveDecimals ?? 18;
+  const amount = parseTokenUnits(options.amount, bTokenDecimals);
+  const user = normalizeUser(options.user, account.address);
+  const calls = [
+    ...await sdk.calls.approval.ensure(options.token, sdk.proxy, amount, {
+      owner: account.address,
+      policy: options.approval
+    }),
+    sdk.calls.staking.deposit(options.token, user, amount)
+  ];
+  if (options.simulate) {
+    return {
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      user,
+      signer: account.address,
+      deposited: serializeAmount(amount, bTokenDecimals),
+      ...await simulatePositionCalls(publicClient, calls, account.address)
+    };
+  }
+  const execution = await executePositionCalls({
+    action: "stake",
+    account: account.address,
+    chain,
+    calls,
+    confirmations: options.confirmations,
+    privateKey: resolvePrivateKey(options.privateKey),
+    rpcUrl: options.rpcUrl
+  });
+  const [stakeAccount, creditAccount, maxBorrow, earned] = await Promise.all([
+    sdk.getStakedAccount(options.token, user),
+    sdk.getCreditAccount(options.token, user),
+    readMaxBorrow(sdk, options.token, user),
+    sdk.getEarned(options.token, user)
+  ]);
+  return {
+    ...serializePosition({
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      name: info.name,
+      symbol: info.symbol,
+      reserve: info.reserve,
+      user,
+      account: stakeAccount,
+      creditAccount,
+      maxBorrow,
+      earned,
+      bTokenDecimals,
+      reserveDecimals
+    }),
+    signer: account.address,
+    deposited: serializeAmount(amount, bTokenDecimals),
+    ...execution
+  };
+}
+async function unstakePosition(options) {
+  const { chain, publicClient, sdk, account } = createWalletSdk(options);
+  const info = await sdk.getBTokenInfo(options.token);
+  const bTokenDecimals = options.bTokenDecimals ?? info.decimals ?? 18;
+  const reserveDecimals = options.reserveDecimals ?? info.reserveDecimals ?? 18;
+  const amount = parseTokenUnits(options.amount, bTokenDecimals);
+  const calls = [sdk.calls.staking.withdraw(options.token, amount)];
+  if (options.simulate) {
+    return {
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      user: account.address,
+      signer: account.address,
+      withdrawn: serializeAmount(amount, bTokenDecimals),
+      ...await simulatePositionCalls(publicClient, calls, account.address)
+    };
+  }
+  const execution = await executePositionCalls({
+    action: "unstake",
+    account: account.address,
+    chain,
+    calls,
+    confirmations: options.confirmations,
+    privateKey: resolvePrivateKey(options.privateKey),
+    rpcUrl: options.rpcUrl
+  });
+  const [stakeAccount, creditAccount, maxBorrow, earned] = await Promise.all([
+    sdk.getStakedAccount(options.token, account.address),
+    sdk.getCreditAccount(options.token, account.address),
+    readMaxBorrow(sdk, options.token, account.address),
+    sdk.getEarned(options.token, account.address)
+  ]);
+  return {
+    ...serializePosition({
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      name: info.name,
+      symbol: info.symbol,
+      reserve: info.reserve,
+      user: account.address,
+      account: stakeAccount,
+      creditAccount,
+      maxBorrow,
+      earned,
+      bTokenDecimals,
+      reserveDecimals
+    }),
+    signer: account.address,
+    withdrawn: serializeAmount(amount, bTokenDecimals),
+    ...execution
+  };
+}
+async function claimPosition(options) {
+  const { chain, publicClient, sdk, account } = createWalletSdk(options);
+  const info = await sdk.getBTokenInfo(options.token);
+  const bTokenDecimals = options.bTokenDecimals ?? info.decimals ?? 18;
+  const reserveDecimals = options.reserveDecimals ?? info.reserveDecimals ?? 18;
+  const user = normalizeUser(options.user, account.address);
+  const amount = await sdk.getEarned(options.token, user);
+  const calls = [
+    sdk.calls.staking.claim(options.token, user, options.asNative)
+  ];
+  if (options.simulate) {
+    return {
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      user,
+      signer: account.address,
+      claimed: serializeAmount(amount, reserveDecimals),
+      asNative: options.asNative,
+      ...await simulatePositionCalls(publicClient, calls, account.address)
+    };
+  }
+  const execution = await executePositionCalls({
+    action: "claim",
+    account: account.address,
+    chain,
+    calls,
+    confirmations: options.confirmations,
+    privateKey: resolvePrivateKey(options.privateKey),
+    rpcUrl: options.rpcUrl
+  });
+  const [stakeAccount, creditAccount, maxBorrow, earned] = await Promise.all([
+    sdk.getStakedAccount(options.token, user),
+    sdk.getCreditAccount(options.token, user),
+    readMaxBorrow(sdk, options.token, user),
+    sdk.getEarned(options.token, user)
+  ]);
+  return {
+    ...serializePosition({
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      name: info.name,
+      symbol: info.symbol,
+      reserve: info.reserve,
+      user,
+      account: stakeAccount,
+      creditAccount,
+      maxBorrow,
+      earned,
+      bTokenDecimals,
+      reserveDecimals
+    }),
+    signer: account.address,
+    claimed: serializeAmount(amount, reserveDecimals),
+    asNative: options.asNative,
+    ...execution
+  };
+}
+async function borrowPosition(options) {
+  const { chain, publicClient, sdk, account } = createWalletSdk(options);
+  const info = await sdk.getBTokenInfo(options.token);
+  const reserveDecimals = options.reserveDecimals ?? info.reserveDecimals ?? 18;
+  const amount = parseTokenUnits(options.amount, reserveDecimals);
+  const recipient = normalizeUser(options.recipient, account.address);
+  const calls = [
+    sdk.calls.credit.borrow(options.token, amount, recipient, {
+      outputNative: options.outputNative
+    })
+  ];
+  if (options.simulate) {
+    return {
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      signer: account.address,
+      recipient,
+      borrowed: serializeAmount(amount, reserveDecimals),
+      outputNative: options.outputNative,
+      ...await simulatePositionCalls(publicClient, calls, account.address)
+    };
+  }
+  const execution = await executePositionCalls({
+    action: "borrow",
+    account: account.address,
+    chain,
+    calls,
+    confirmations: options.confirmations,
+    privateKey: resolvePrivateKey(options.privateKey),
+    rpcUrl: options.rpcUrl
+  });
+  const [stakeAccount, creditAccount, maxBorrow, earned] = await Promise.all([
+    sdk.getStakedAccount(options.token, account.address),
+    sdk.getCreditAccount(options.token, account.address),
+    readMaxBorrow(sdk, options.token, account.address),
+    sdk.getEarned(options.token, account.address)
+  ]);
+  return {
+    ...serializePosition({
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      name: info.name,
+      symbol: info.symbol,
+      reserve: info.reserve,
+      user: account.address,
+      account: stakeAccount,
+      creditAccount,
+      maxBorrow,
+      earned,
+      bTokenDecimals: options.bTokenDecimals ?? info.decimals ?? 18,
+      reserveDecimals
+    }),
+    signer: account.address,
+    recipient,
+    borrowed: serializeAmount(amount, reserveDecimals),
+    outputNative: options.outputNative,
+    ...execution
+  };
+}
+async function repayPosition(options) {
+  const { chain, publicClient, sdk, account } = createWalletSdk(options);
+  const info = await sdk.getBTokenInfo(options.token);
+  if (!options.useNative && !info.reserve) {
+    throw new Error("Token reserve is unavailable.");
+  }
+  const reserveDecimals = options.reserveDecimals ?? info.reserveDecimals ?? 18;
+  const amount = parseTokenUnits(options.amount, reserveDecimals);
+  const recipient = normalizeUser(options.recipient, account.address);
+  const calls = [
+    ...options.useNative ? [] : await sdk.calls.approval.ensure(info.reserve, sdk.proxy, amount, {
+      owner: account.address,
+      policy: options.approval
+    }),
+    sdk.calls.credit.repay(options.token, amount, recipient, {
+      useNative: options.useNative
+    })
+  ];
+  if (options.simulate) {
+    return {
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      signer: account.address,
+      recipient,
+      repaid: serializeAmount(amount, reserveDecimals),
+      useNative: options.useNative,
+      ...await simulatePositionCalls(publicClient, calls, account.address)
+    };
+  }
+  const execution = await executePositionCalls({
+    action: "repay",
+    account: account.address,
+    chain,
+    calls,
+    confirmations: options.confirmations,
+    privateKey: resolvePrivateKey(options.privateKey),
+    rpcUrl: options.rpcUrl
+  });
+  const [stakeAccount, creditAccount, maxBorrow, earned] = await Promise.all([
+    sdk.getStakedAccount(options.token, recipient),
+    sdk.getCreditAccount(options.token, recipient),
+    readMaxBorrow(sdk, options.token, recipient),
+    sdk.getEarned(options.token, recipient)
+  ]);
+  return {
+    ...serializePosition({
+      chainId: chain.id,
+      chain: chainName(chain),
+      token: options.token,
+      name: info.name,
+      symbol: info.symbol,
+      reserve: info.reserve,
+      user: recipient,
+      account: stakeAccount,
+      creditAccount,
+      maxBorrow,
+      earned,
+      bTokenDecimals: options.bTokenDecimals ?? info.decimals ?? 18,
+      reserveDecimals
+    }),
+    signer: account.address,
+    recipient,
+    repaid: serializeAmount(amount, reserveDecimals),
+    useNative: options.useNative,
+    ...execution
+  };
+}
+
+// src/commands/position/index.ts
+var positionCommand = {
+  description: "Inspect and manage a Baseline position.",
+  options: accountOptions,
+  async run({
+    options,
+    formatExplicit
+  }) {
+    const position = await readPosition(options);
+    return formatExplicit ? position : formatPosition(position);
+  }
+};
+var positionStakeCommand = {
+  description: "Stake BTokens into a Baseline position.",
+  options: stakeOptions,
+  run: ({ options }) => stakePosition(options)
+};
+var positionUnstakeCommand = {
+  description: "Withdraw staked BTokens from a Baseline position.",
+  options: unstakeOptions,
+  run: ({ options }) => unstakePosition(options)
+};
+var positionClaimCommand = {
+  description: "Claim position rewards.",
+  options: claimOptions,
+  run: ({ options }) => claimPosition(options)
+};
+var positionBorrowCommand = {
+  description: "Borrow reserves against a Baseline position.",
+  options: borrowOptions,
+  run: ({ options }) => borrowPosition(options)
+};
+var positionRepayCommand = {
+  description: "Repay reserves for a Baseline position.",
+  options: repayOptions,
+  run: ({ options }) => repayPosition(options)
+};
+
 // src/env.ts
 import { existsSync, readFileSync } from "node:fs";
 import { dirname as dirname2, resolve } from "node:path";
@@ -447,18 +1438,45 @@ function loadEnv(path) {
 
 // src/index.ts
 loadCliEnv();
-var cli = Cli.create("baseline", {
+var cli = Cli2.create("baseline", {
   version: "0.2.0",
   description: "Baseline Markets CLI",
   sync: {
     include: [skillsGlob],
     suggestions: [
       "build launch calls for a new Baseline token",
-      "output launch calls as JSON for wallet_sendCalls"
+      "output launch calls as JSON for wallet_sendCalls",
+      "quote a Baseline token swap",
+      "manage a Baseline position"
     ]
   }
-}).command("launch", launchCommand).command("info", infoCommand);
-await cli.serve();
+}).command("launch", launchCommand).command("info", infoCommand).command(quoteCommand).command("swap", swapCommand).command("position", positionCommand).command("position stake", positionStakeCommand).command("position unstake", positionUnstakeCommand).command("position claim", positionClaimCommand).command("position borrow", positionBorrowCommand).command("position repay", positionRepayCommand);
+function normalizeArgv(argv) {
+  const [command, subcommand, ...rest] = argv;
+  switch (command) {
+    case "position":
+      switch (subcommand) {
+        case "stake":
+        case "unstake":
+        case "claim":
+        case "borrow":
+        case "repay":
+          if (rest[0] && !rest[0].startsWith("-")) {
+            return [`position ${subcommand} ${rest[0]}`, ...rest.slice(1)];
+          }
+          return [`position ${subcommand}`, ...rest];
+      }
+  }
+  return argv;
+}
+function serveCli(argv = process.argv.slice(2), options) {
+  return cli.serve(normalizeArgv(argv), options);
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await serveCli();
+}
 export {
+  serveCli,
+  normalizeArgv,
   cli
 };