moneyos 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,75 +1,11 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  MoneyOS: () => MoneyOS,
-  NATIVE_TOKEN_ADDRESS: () => NATIVE_TOKEN_ADDRESS,
-  OdosProvider: () => OdosProvider,
-  chains: () => chains,
-  defaultChain: () => defaultChain,
-  getChain: () => getChain,
-  getToken: () => getToken,
-  getTokenAddress: () => getTokenAddress,
-  tokens: () => tokens
-});
-module.exports = __toCommonJS(src_exports);
-
 // src/core/client.ts
-var import_viem = require("viem");
-var import_accounts = require("viem/accounts");
-var import_chains = require("viem/chains");
-
-// src/core/chains.ts
-var chains = {
-  arbitrum: {
-    id: 42161,
-    name: "Arbitrum One",
-    rpcUrl: "https://arb1.arbitrum.io/rpc",
-    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-    blockExplorer: "https://arbiscan.io"
-  },
-  ethereum: {
-    id: 1,
-    name: "Ethereum",
-    rpcUrl: "https://eth.public-rpc.com",
-    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-    blockExplorer: "https://etherscan.io"
-  },
-  polygon: {
-    id: 137,
-    name: "Polygon",
-    rpcUrl: "https://polygon-rpc.com",
-    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
-    blockExplorer: "https://polygonscan.com"
-  }
-};
-var defaultChain = chains.arbitrum;
-function getChain(idOrName) {
-  if (typeof idOrName === "number") {
-    return Object.values(chains).find((c) => c.id === idOrName);
-  }
-  return chains[idOrName.toLowerCase()];
-}
+import {
+  formatUnits as formatUnits2,
+  parseUnits as parseUnits2,
+  encodeFunctionData as encodeFunctionData2
+} from "viem";
 
-// src/core/tokens.ts
+// packages/core/dist/index.js
 var NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 var tokens = {
   ETH: {
@@ -78,7 +14,14 @@ var tokens = {
     decimals: 18,
     addresses: {
       42161: NATIVE_TOKEN_ADDRESS,
-      1: NATIVE_TOKEN_ADDRESS,
+      1: NATIVE_TOKEN_ADDRESS
+    }
+  },
+  POL: {
+    symbol: "POL",
+    name: "POL",
+    decimals: 18,
+    addresses: {
       137: NATIVE_TOKEN_ADDRESS
     }
   },
@@ -117,9 +60,265 @@ function getToken(symbol) {
 function getTokenAddress(symbol, chainId) {
   return getToken(symbol)?.addresses[chainId];
 }
+var chains = {
+  arbitrum: {
+    id: 42161,
+    name: "Arbitrum One",
+    rpcUrl: "https://arb1.arbitrum.io/rpc",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://arbiscan.io"
+  },
+  ethereum: {
+    id: 1,
+    name: "Ethereum",
+    rpcUrl: "https://eth.public-rpc.com",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://etherscan.io"
+  },
+  polygon: {
+    id: 137,
+    name: "Polygon",
+    rpcUrl: "https://polygon-rpc.com",
+    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
+    blockExplorer: "https://polygonscan.com"
+  }
+};
+var defaultChain = chains.arbitrum;
+function getChain(idOrName) {
+  if (typeof idOrName === "number") {
+    return Object.values(chains).find((c) => c.id === idOrName);
+  }
+  return chains[idOrName.toLowerCase()];
+}
 
-// src/core/client.ts
+// src/core/eoa.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http
+} from "viem";
+import { arbitrum, mainnet, polygon } from "viem/chains";
+
+// src/core/signer.ts
+import { nonceManager } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+function privateKeyToManagedAccount(privateKey) {
+  return privateKeyToAccount(privateKey, { nonceManager });
+}
+
+// src/core/eoa.ts
+var viemChainMap = {
+  42161: arbitrum,
+  1: mainnet,
+  137: polygon
+};
+function getViemChain(chainId) {
+  return viemChainMap[chainId];
+}
+var ViemReadClient = class {
+  clients = /* @__PURE__ */ new Map();
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getClient(chainId) {
+    let client = this.clients.get(chainId);
+    if (!client) {
+      const chain = getViemChain(chainId);
+      const chainInfo = getChain(chainId);
+      const rpcUrl = chainId === this.config.defaultChainId ? this.config.rpcUrl : void 0;
+      client = createPublicClient({
+        chain,
+        transport: http(rpcUrl ?? chainInfo?.rpcUrl)
+      });
+      this.clients.set(chainId, client);
+    }
+    return client;
+  }
+  async getBalance(params) {
+    const client = this.getClient(params.chainId);
+    return client.getBalance({ address: params.address });
+  }
+  async readContract(params) {
+    const client = this.getClient(params.chainId);
+    return client.readContract({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      args: params.args
+    });
+  }
+};
+var EOAExecutor = class _EOAExecutor {
+  mode = "eoa";
+  signer;
+  walletClients = /* @__PURE__ */ new Map();
+  publicClients = /* @__PURE__ */ new Map();
+  config;
+  constructor(signer, config) {
+    this.signer = signer;
+    this.config = config;
+  }
+  /**
+   * Convenience factory: build an EOAExecutor from a raw private key.
+   * Equivalent to `new EOAExecutor(privateKeyToAccount(privateKey), config)`.
+   * Kept as a helper so the common "I have a hex key" path stays one line
+   * while the constructor itself takes a viem `Account` to accommodate
+   * future keystore-backed signers (hardware, KMS, MPC).
+   *
+   * Attach viem's nonce manager so back-to-back live transactions use a
+   * pending-aware nonce source instead of relying on RPC fill behavior.
+   */
+  static fromPrivateKey(privateKey, config) {
+    return new _EOAExecutor(privateKeyToManagedAccount(privateKey), config);
+  }
+  getWalletClient(chainId) {
+    let client = this.walletClients.get(chainId);
+    if (!client) {
+      const chain = getViemChain(chainId);
+      const chainInfo = getChain(chainId);
+      const rpcUrl = chainId === this.config.defaultChainId ? this.config.rpcUrl : void 0;
+      client = createWalletClient({
+        account: this.signer,
+        chain,
+        transport: http(rpcUrl ?? chainInfo?.rpcUrl)
+      });
+      this.walletClients.set(chainId, client);
+    }
+    return client;
+  }
+  getPublicClient(chainId) {
+    let client = this.publicClients.get(chainId);
+    if (!client) {
+      const chain = getViemChain(chainId);
+      const chainInfo = getChain(chainId);
+      const rpcUrl = chainId === this.config.defaultChainId ? this.config.rpcUrl : void 0;
+      client = createPublicClient({
+        chain,
+        transport: http(rpcUrl ?? chainInfo?.rpcUrl)
+      });
+      this.publicClients.set(chainId, client);
+    }
+    return client;
+  }
+  getAddress() {
+    return this.signer.address;
+  }
+  async send(call) {
+    const walletClient = this.getWalletClient(call.chainId);
+    const hash = await walletClient.sendTransaction({
+      account: walletClient.account,
+      to: call.to,
+      data: call.data,
+      value: call.value ?? 0n,
+      chain: walletClient.chain
+    });
+    const publicClient = this.getPublicClient(call.chainId);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    if (receipt.status !== "success") {
+      throw new Error(
+        `Transaction ${hash} reverted on chain ${call.chainId} (block ${receipt.blockNumber}).`
+      );
+    }
+    return { hash, chainId: call.chainId };
+  }
+  capabilities() {
+    return {
+      sponsoredGas: false,
+      batching: false,
+      simulation: false
+    };
+  }
+};
+
+// src/tools/swap.ts
+import {
+  formatUnits,
+  parseUnits,
+  encodeFunctionData
+} from "viem";
 var ERC20_ABI = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+async function executeSwap(input, ctx) {
+  const { tokenIn, tokenOut, amount, provider, chainId, slippage } = input;
+  const { read, execute, assets } = ctx;
+  const sender = execute.getAddress();
+  const tokenInAddress = assets.getTokenAddress(tokenIn, chainId);
+  const tokenOutAddress = assets.getTokenAddress(tokenOut, chainId);
+  if (!tokenInAddress) {
+    throw new Error(`Token ${tokenIn} not found on chain ${chainId}`);
+  }
+  if (!tokenOutAddress) {
+    throw new Error(`Token ${tokenOut} not found on chain ${chainId}`);
+  }
+  const tokenInInfo = assets.getToken(tokenIn);
+  const amountWei = parseUnits(amount, tokenInInfo.decimals);
+  const quote = await provider.getQuote({
+    chainId,
+    tokenIn: tokenInAddress,
+    tokenOut: tokenOutAddress,
+    amount: amountWei,
+    sender,
+    slippage
+  });
+  const calldata = await provider.getCalldata(quote);
+  const isNativeIn = tokenInAddress === assets.nativeTokenAddress;
+  if (!isNativeIn) {
+    const currentAllowance = await read.readContract({
+      address: tokenInAddress,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [sender, calldata.to],
+      chainId
+    });
+    if (currentAllowance < amountWei) {
+      const approveData = encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [calldata.to, amountWei]
+      });
+      await execute.send({ to: tokenInAddress, data: approveData, chainId });
+    }
+  }
+  const result = await execute.send({
+    to: calldata.to,
+    data: calldata.data,
+    value: isNativeIn ? amountWei : calldata.value,
+    chainId
+  });
+  const tokenOutInfo = assets.getToken(tokenOut);
+  return {
+    hash: result.hash,
+    tokenIn: tokenInInfo.symbol,
+    tokenOut: tokenOutInfo.symbol,
+    amountIn: amount,
+    amountOut: formatUnits(BigInt(quote.expectedOut), tokenOutInfo.decimals),
+    chainId
+  };
+}
+
+// src/core/client.ts
+var ERC20_ABI2 = [
   {
     name: "balanceOf",
     type: "function",
@@ -150,221 +349,158 @@ var ERC20_ABI = [
     stateMutability: "view",
     inputs: [],
     outputs: [{ name: "", type: "string" }]
-  },
-  {
-    name: "approve",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }]
-  },
-  {
-    name: "allowance",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "", type: "uint256" }]
   }
 ];
-var viemChains = {
-  42161: import_chains.arbitrum,
-  1: import_chains.mainnet,
-  137: import_chains.polygon
+var DefaultAssetRegistry = class {
+  nativeTokenAddress = NATIVE_TOKEN_ADDRESS;
+  getToken = getToken;
+  getTokenAddress = getTokenAddress;
+  getChain = getChain;
 };
 var MoneyOS = class {
-  config;
-  publicClients = /* @__PURE__ */ new Map();
-  walletClient;
+  read;
+  executor;
+  assets;
+  runtimeConfig;
   constructor(config) {
-    this.config = {
-      ...config,
-      chainId: config.chainId ?? defaultChain.id
+    const provided = [];
+    if (config.execute) provided.push("execute");
+    if (config.privateKey) provided.push("privateKey");
+    if (config.signer) provided.push("signer");
+    if (provided.length > 1) {
+      throw new Error(
+        `MoneyOSConfig: pass at most one of \`execute\`, \`privateKey\`, or \`signer\`. Received: ${provided.join(", ")}.`
+      );
+    }
+    this.runtimeConfig = {
+      defaultChainId: config.chainId ?? defaultChain.id,
+      rpcUrl: config.rpcUrl
     };
-  }
-  getPublicClient(chainId) {
-    const id = chainId ?? this.config.chainId;
-    let client = this.publicClients.get(id);
-    if (!client) {
-      const chain = viemChains[id];
-      const chainInfo = getChain(id);
-      const rpcUrl = id === this.config.chainId ? this.config.rpcUrl : void 0;
-      client = (0, import_viem.createPublicClient)({
-        chain,
-        transport: (0, import_viem.http)(rpcUrl ?? chainInfo?.rpcUrl)
-      });
-      this.publicClients.set(id, client);
+    this.read = config.read ?? new ViemReadClient(this.runtimeConfig);
+    this.assets = config.assets ?? new DefaultAssetRegistry();
+    if (config.execute) {
+      this.executor = config.execute;
+    } else if (config.signer) {
+      this.executor = new EOAExecutor(config.signer, this.runtimeConfig);
+    } else if (config.privateKey) {
+      this.executor = EOAExecutor.fromPrivateKey(
+        config.privateKey,
+        this.runtimeConfig
+      );
     }
-    return client;
   }
-  getWalletClient() {
-    if (!this.walletClient) {
-      if (!this.config.privateKey) {
-        throw new Error(
-          "No private key configured. Set privateKey in MoneyOS config."
-        );
-      }
-      const account = (0, import_accounts.privateKeyToAccount)(this.config.privateKey);
-      const chain = viemChains[this.config.chainId];
-      const chainInfo = getChain(this.config.chainId);
-      this.walletClient = (0, import_viem.createWalletClient)({
-        account,
-        chain,
-        transport: (0, import_viem.http)(this.config.rpcUrl ?? chainInfo?.rpcUrl)
-      });
-    }
-    return this.walletClient;
+  get runtime() {
+    return {
+      read: this.read,
+      execute: this.requireExecutor(),
+      assets: this.assets,
+      config: this.runtimeConfig
+    };
   }
   get address() {
-    if (!this.config.privateKey) {
-      throw new Error("No private key configured.");
+    return this.requireExecutor().getAddress();
+  }
+  requireExecutor() {
+    if (!this.executor) {
+      throw new Error(
+        "No signing account configured. Set `signer`, `privateKey`, or `execute` in MoneyOS config."
+      );
     }
-    return (0, import_accounts.privateKeyToAccount)(this.config.privateKey).address;
+    return this.executor;
   }
   async balance(token, options) {
-    const chainId = options?.chainId ?? this.config.chainId;
+    const chainId = options?.chainId ?? this.runtimeConfig.defaultChainId;
     const account = options?.address ?? this.address;
-    const client = this.getPublicClient(chainId);
-    if (token.toUpperCase() === "ETH") {
-      const raw2 = await client.getBalance({ address: account });
+    const tokenAddress = this.assets.getTokenAddress(token, chainId);
+    if (!tokenAddress) {
+      throw new Error(`Token ${token} not found on chain ${chainId}`);
+    }
+    const tokenInfo = this.assets.getToken(token);
+    if (tokenAddress === NATIVE_TOKEN_ADDRESS) {
+      const raw2 = await this.read.getBalance({ address: account, chainId });
       return {
-        token: "ETH",
-        symbol: "ETH",
-        amount: (0, import_viem.formatUnits)(raw2, 18),
+        token: tokenInfo.name,
+        symbol: tokenInfo.symbol,
+        amount: formatUnits2(raw2, tokenInfo.decimals),
         rawAmount: raw2,
-        decimals: 18,
+        decimals: tokenInfo.decimals,
         chainId
       };
     }
-    const tokenAddress = getTokenAddress(token, chainId);
-    if (!tokenAddress) {
-      throw new Error(`Token ${token} not found on chain ${chainId}`);
-    }
-    const tokenInfo = getToken(token);
-    const raw = await client.readContract({
+    const raw = await this.read.readContract({
       address: tokenAddress,
-      abi: ERC20_ABI,
+      abi: ERC20_ABI2,
       functionName: "balanceOf",
-      args: [account]
+      args: [account],
+      chainId
     });
     return {
       token: tokenInfo.name,
       symbol: tokenInfo.symbol,
-      amount: (0, import_viem.formatUnits)(raw, tokenInfo.decimals),
+      amount: formatUnits2(raw, tokenInfo.decimals),
       rawAmount: raw,
       decimals: tokenInfo.decimals,
       chainId
     };
   }
   async send(token, to, amount, options) {
-    const chainId = options?.chainId ?? this.config.chainId;
-    const walletClient = this.getWalletClient();
-    const from = this.address;
-    if (token.toUpperCase() === "ETH") {
-      const value2 = (0, import_viem.parseUnits)(amount, 18);
-      const account = (0, import_accounts.privateKeyToAccount)(this.config.privateKey);
-      const hash2 = await walletClient.sendTransaction({
-        account,
-        to,
-        value: value2,
-        chain: viemChains[chainId]
-      });
-      return { hash: hash2, from, to, amount, token: "ETH", chainId };
-    }
-    const tokenAddress = getTokenAddress(token, chainId);
+    const execute = this.requireExecutor();
+    const chainId = options?.chainId ?? this.runtimeConfig.defaultChainId;
+    const from = execute.getAddress();
+    const tokenAddress = this.assets.getTokenAddress(token, chainId);
     if (!tokenAddress) {
       throw new Error(`Token ${token} not found on chain ${chainId}`);
     }
-    const tokenInfo = getToken(token);
-    const value = (0, import_viem.parseUnits)(amount, tokenInfo.decimals);
-    const client = this.getPublicClient(chainId);
-    const { request } = await client.simulateContract({
-      address: tokenAddress,
-      abi: ERC20_ABI,
-      functionName: "transfer",
-      args: [to, value],
-      account: (0, import_accounts.privateKeyToAccount)(this.config.privateKey)
-    });
-    const hash = await walletClient.writeContract(request);
-    return { hash, from, to, amount, token: tokenInfo.symbol, chainId };
-  }
-  async swap(tokenIn, tokenOut, amount, provider, options) {
-    const chainId = options?.chainId ?? this.config.chainId;
-    const walletClient = this.getWalletClient();
-    const client = this.getPublicClient(chainId);
-    const sender = this.address;
-    const tokenInAddress = getTokenAddress(tokenIn, chainId);
-    const tokenOutAddress = getTokenAddress(tokenOut, chainId);
-    if (!tokenInAddress) {
-      throw new Error(`Token ${tokenIn} not found on chain ${chainId}`);
-    }
-    if (!tokenOutAddress) {
-      throw new Error(`Token ${tokenOut} not found on chain ${chainId}`);
-    }
-    const tokenInInfo = getToken(tokenIn);
-    const amountWei = (0, import_viem.parseUnits)(amount, tokenInInfo.decimals);
-    const quote = await provider.getQuote({
-      chainId,
-      tokenIn: tokenInAddress,
-      tokenOut: tokenOutAddress,
-      amount: amountWei,
-      sender,
-      slippage: options?.slippage
-    });
-    const calldata = await provider.getCalldata(quote);
-    const isNativeIn = tokenInAddress === NATIVE_TOKEN_ADDRESS;
-    if (!isNativeIn) {
-      const currentAllowance = await client.readContract({
-        address: tokenInAddress,
-        abi: ERC20_ABI,
-        functionName: "allowance",
-        args: [sender, calldata.to]
-      });
-      if (currentAllowance < amountWei) {
-        const account2 = (0, import_accounts.privateKeyToAccount)(this.config.privateKey);
-        const { request: approveRequest } = await client.simulateContract({
-          address: tokenInAddress,
-          abi: ERC20_ABI,
-          functionName: "approve",
-          args: [calldata.to, amountWei],
-          account: account2
-        });
-        await walletClient.writeContract(approveRequest);
-      }
+    const tokenInfo = this.assets.getToken(token);
+    const value = parseUnits2(amount, tokenInfo.decimals);
+    if (tokenAddress === NATIVE_TOKEN_ADDRESS) {
+      const result2 = await execute.send({ to, value, chainId });
+      return {
+        hash: result2.hash,
+        from,
+        to,
+        amount,
+        token: tokenInfo.symbol,
+        chainId
+      };
     }
-    const account = (0, import_accounts.privateKeyToAccount)(this.config.privateKey);
-    const hash = await walletClient.sendTransaction({
-      account,
-      to: calldata.to,
-      data: calldata.data,
-      value: isNativeIn ? amountWei : calldata.value,
-      chain: viemChains[chainId]
+    const data = encodeFunctionData2({
+      abi: ERC20_ABI2,
+      functionName: "transfer",
+      args: [to, value]
     });
-    const tokenOutInfo = getToken(tokenOut);
+    const result = await execute.send({ to: tokenAddress, data, chainId });
     return {
-      hash,
-      tokenIn: tokenInInfo.symbol,
-      tokenOut: tokenOutInfo.symbol,
-      amountIn: amount,
-      amountOut: (0, import_viem.formatUnits)(BigInt(quote.expectedOut), tokenOutInfo.decimals),
+      hash: result.hash,
+      from,
+      to,
+      amount,
+      token: tokenInfo.symbol,
       chainId
     };
   }
+  async swap(tokenIn, tokenOut, amount, provider, options) {
+    const execute = this.requireExecutor();
+    const chainId = options?.chainId ?? this.runtimeConfig.defaultChainId;
+    return executeSwap(
+      { tokenIn, tokenOut, amount, provider, chainId, slippage: options?.slippage },
+      { read: this.read, execute, assets: this.assets }
+    );
+  }
 };
 
 // src/providers/odos.ts
 var ODOS_API = "https://api.odos.xyz";
+var ODOS_NATIVE_ADDRESS = "0x0000000000000000000000000000000000000000";
 var OdosProvider = class {
   name = "odos";
   apiKey;
   constructor(options) {
     this.apiKey = options?.apiKey;
   }
+  toOdosAddress(address) {
+    return address === NATIVE_TOKEN_ADDRESS ? ODOS_NATIVE_ADDRESS : address;
+  }
   async getQuote(params) {
     const headers = {
       "Content-Type": "application/json"
@@ -379,13 +515,13 @@ var OdosProvider = class {
         chainId: params.chainId,
         inputTokens: [
           {
-            tokenAddress: params.tokenIn,
+            tokenAddress: this.toOdosAddress(params.tokenIn),
             amount: params.amount.toString()
           }
         ],
         outputTokens: [
           {
-            tokenAddress: params.tokenOut,
+            tokenAddress: this.toOdosAddress(params.tokenOut),
             proportion: 1
           }
         ],
@@ -407,7 +543,8 @@ var OdosProvider = class {
       expectedOut: data.outAmounts[0],
       router: "",
       chainId: params.chainId,
-      pathId: data.pathId
+      pathId: data.pathId,
+      sender: params.sender
     };
   }
   async getCalldata(quote) {
@@ -421,7 +558,7 @@ var OdosProvider = class {
       method: "POST",
       headers,
       body: JSON.stringify({
-        userAddr: quote.tokenIn,
+        userAddr: quote.sender,
         pathId: quote.pathId,
         simulate: false
       })
@@ -438,16 +575,118 @@ var OdosProvider = class {
     };
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+
+// src/core/access-local.ts
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+var LocalAccessSession = class {
+  kind = "local";
+  address;
+  constructor(privateKey) {
+    this.address = privateKeyToAccount2(privateKey).address;
+  }
+  getAddress() {
+    return this.address;
+  }
+};
+var LocalAccessAdapter = class {
+  name = "local";
+  privateKey;
+  constructor(privateKey) {
+    this.privateKey = privateKey;
+  }
+  async openSession(_ctx) {
+    return new LocalAccessSession(this.privateKey);
+  }
+};
+
+// src/core/keystore-file.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+var DEFAULT_CONFIG_PATH = join(homedir(), ".moneyos", "config.json");
+var FileKeyStore = class {
+  kind = "file";
+  configPath;
+  constructor(options = {}) {
+    this.configPath = options.configPath ?? DEFAULT_CONFIG_PATH;
+  }
+  async hasKey() {
+    const config = this.readConfig();
+    return Boolean(config?.privateKey);
+  }
+  async metadata() {
+    const config = this.readConfig();
+    const address = config?.privateKey ? privateKeyToAccount3(config.privateKey).address : void 0;
+    return {
+      kind: "file",
+      address
+    };
+  }
+  async loadSigner() {
+    const config = this.readConfig();
+    if (!config?.privateKey) {
+      throw new Error(
+        `FileKeyStore: no private key found at ${this.configPath}. Run \`moneyos init\` to create one.`
+      );
+    }
+    return privateKeyToManagedAccount(config.privateKey);
+  }
+  /**
+   * Read and validate the config file. Returns `undefined` if the file does
+   * not exist. Throws with context for any other failure mode (malformed
+   * JSON, wrong top-level type, wrong `privateKey` type). The hex format of
+   * the key itself is validated later by viem's `privateKeyToAccount`.
+   */
+  readConfig() {
+    if (!existsSync(this.configPath)) {
+      return void 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(this.configPath, "utf-8"));
+    } catch (error) {
+      throw new Error(
+        `FileKeyStore: failed to read config at ${this.configPath}`,
+        { cause: error }
+      );
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error(
+        `FileKeyStore: config at ${this.configPath} is not a JSON object`
+      );
+    }
+    const pk = parsed.privateKey;
+    if (pk === void 0 || pk === null) {
+      return {};
+    }
+    if (typeof pk !== "string") {
+      throw new Error(
+        `FileKeyStore: privateKey at ${this.configPath} must be a string`
+      );
+    }
+    return { privateKey: pk };
+  }
+};
+
+// src/core/factory.ts
+function createMoneyOS(config) {
+  return new MoneyOS(config);
+}
+export {
+  EOAExecutor,
+  FileKeyStore,
+  LocalAccessAdapter,
   MoneyOS,
   NATIVE_TOKEN_ADDRESS,
   OdosProvider,
+  ViemReadClient,
   chains,
+  createMoneyOS,
   defaultChain,
   getChain,
   getToken,
   getTokenAddress,
   tokens
-});
+};
 //# sourceMappingURL=index.js.map