@riftresearch/sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,1390 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/@cowprotocol/sdk-common/dist/index.js
+var require_dist = __commonJS((exports, module) => {
+  var __defProp2 = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames2 = Object.getOwnPropertyNames;
+  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp2(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 __getOwnPropNames2(from))
+        if (!__hasOwnProp2.call(to, key) && key !== except)
+          __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp2({}, "__esModule", { value: true }), mod);
+  var src_exports = {};
+  __export(src_exports, {
+    AbstractProviderAdapter: () => AbstractProviderAdapter,
+    AbstractSigner: () => AbstractSigner,
+    AdapterContext: () => AdapterContext,
+    AdapterUtils: () => AdapterUtils,
+    ContractFactory: () => ContractFactory,
+    CowError: () => CowError,
+    ERC20_ALLOWANCE_ABI: () => ERC20_ALLOWANCE_ABI,
+    ERC20_APPROVE_ABI: () => ERC20_APPROVE_ABI,
+    EthFlowAbi: () => EthFlowAbi,
+    GPV2SettlementAbi: () => GPV2SettlementAbi,
+    MAX_UINT256: () => MAX_UINT256,
+    MAX_UINT32: () => MAX_UINT32,
+    ONE: () => ONE,
+    TTLCache: () => TTLCache,
+    ZERO: () => ZERO,
+    ZERO_ADDRESS: () => ZERO_ADDRESS,
+    ZERO_HASH: () => ZERO_HASH,
+    applyPercentage: () => applyPercentage,
+    bpsToPercentage: () => bpsToPercentage,
+    enableLogging: () => enableLogging,
+    getGlobalAdapter: () => getGlobalAdapter,
+    isValidPrivateKey: () => isValidPrivateKey,
+    jsonWithBigintReplacer: () => jsonWithBigintReplacer,
+    log: () => log,
+    normalizePrivateKey: () => normalizePrivateKey,
+    percentageToBps: () => percentageToBps,
+    setGlobalAdapter: () => setGlobalAdapter
+  });
+  module.exports = __toCommonJS(src_exports);
+  var AbstractProviderAdapter = class {
+    ZERO_ADDRESS;
+  };
+  var AdapterUtils = class {
+  };
+  var MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+  var EthFlowAbi = [
+    {
+      inputs: [
+        {
+          components: [
+            {
+              internalType: "contract IERC20",
+              name: "buyToken",
+              type: "address"
+            },
+            {
+              internalType: "address",
+              name: "receiver",
+              type: "address"
+            },
+            {
+              internalType: "uint256",
+              name: "sellAmount",
+              type: "uint256"
+            },
+            {
+              internalType: "uint256",
+              name: "buyAmount",
+              type: "uint256"
+            },
+            {
+              internalType: "bytes32",
+              name: "appData",
+              type: "bytes32"
+            },
+            {
+              internalType: "uint256",
+              name: "feeAmount",
+              type: "uint256"
+            },
+            {
+              internalType: "uint32",
+              name: "validTo",
+              type: "uint32"
+            },
+            {
+              internalType: "bool",
+              name: "partiallyFillable",
+              type: "bool"
+            },
+            {
+              internalType: "int64",
+              name: "quoteId",
+              type: "int64"
+            }
+          ],
+          internalType: "struct EthFlowOrder.Data",
+          name: "order",
+          type: "tuple"
+        }
+      ],
+      name: "createOrder",
+      outputs: [
+        {
+          internalType: "bytes32",
+          name: "orderHash",
+          type: "bytes32"
+        }
+      ],
+      stateMutability: "payable",
+      type: "function"
+    },
+    {
+      inputs: [
+        {
+          components: [
+            {
+              internalType: "contract IERC20",
+              name: "buyToken",
+              type: "address"
+            },
+            {
+              internalType: "address",
+              name: "receiver",
+              type: "address"
+            },
+            {
+              internalType: "uint256",
+              name: "sellAmount",
+              type: "uint256"
+            },
+            {
+              internalType: "uint256",
+              name: "buyAmount",
+              type: "uint256"
+            },
+            {
+              internalType: "bytes32",
+              name: "appData",
+              type: "bytes32"
+            },
+            {
+              internalType: "uint256",
+              name: "feeAmount",
+              type: "uint256"
+            },
+            {
+              internalType: "uint32",
+              name: "validTo",
+              type: "uint32"
+            },
+            {
+              internalType: "bool",
+              name: "partiallyFillable",
+              type: "bool"
+            },
+            {
+              internalType: "int64",
+              name: "quoteId",
+              type: "int64"
+            }
+          ],
+          internalType: "struct EthFlowOrder.Data",
+          name: "order",
+          type: "tuple"
+        }
+      ],
+      name: "invalidateOrder",
+      outputs: [],
+      stateMutability: "nonpayable",
+      type: "function"
+    },
+    {
+      inputs: [
+        {
+          internalType: "bytes32",
+          name: "",
+          type: "bytes32"
+        }
+      ],
+      name: "orders",
+      outputs: [
+        {
+          internalType: "address",
+          name: "owner",
+          type: "address"
+        },
+        {
+          internalType: "uint32",
+          name: "validTo",
+          type: "uint32"
+        }
+      ],
+      stateMutability: "view",
+      type: "function"
+    }
+  ];
+  var GPV2SettlementAbi = [
+    {
+      anonymous: false,
+      inputs: [
+        {
+          indexed: true,
+          internalType: "address",
+          name: "owner",
+          type: "address"
+        },
+        {
+          indexed: false,
+          internalType: "contract IERC20",
+          name: "sellToken",
+          type: "address"
+        },
+        {
+          indexed: false,
+          internalType: "contract IERC20",
+          name: "buyToken",
+          type: "address"
+        },
+        {
+          indexed: false,
+          internalType: "uint256",
+          name: "sellAmount",
+          type: "uint256"
+        },
+        {
+          indexed: false,
+          internalType: "uint256",
+          name: "buyAmount",
+          type: "uint256"
+        },
+        {
+          indexed: false,
+          internalType: "uint256",
+          name: "feeAmount",
+          type: "uint256"
+        },
+        {
+          indexed: false,
+          internalType: "bytes",
+          name: "orderUid",
+          type: "bytes"
+        }
+      ],
+      name: "Trade",
+      type: "event"
+    },
+    {
+      inputs: [
+        {
+          internalType: "bytes",
+          name: "orderUid",
+          type: "bytes"
+        },
+        {
+          internalType: "bool",
+          name: "signed",
+          type: "bool"
+        }
+      ],
+      name: "setPreSignature",
+      outputs: [],
+      stateMutability: "nonpayable",
+      type: "function"
+    },
+    {
+      inputs: [
+        {
+          internalType: "bytes",
+          name: "orderUid",
+          type: "bytes"
+        }
+      ],
+      name: "invalidateOrder",
+      outputs: [],
+      stateMutability: "nonpayable",
+      type: "function"
+    },
+    {
+      inputs: [],
+      name: "domainSeparator",
+      outputs: [{ name: "", type: "bytes32" }],
+      stateMutability: "nonpayable",
+      type: "function"
+    }
+  ];
+  var ERC20_APPROVE_ABI = [
+    {
+      constant: false,
+      inputs: [
+        {
+          name: "_spender",
+          type: "address"
+        },
+        {
+          name: "_value",
+          type: "uint256"
+        }
+      ],
+      name: "approve",
+      outputs: [
+        {
+          name: "",
+          type: "bool"
+        }
+      ],
+      payable: false,
+      stateMutability: "nonpayable",
+      type: "function"
+    }
+  ];
+  var ERC20_ALLOWANCE_ABI = [
+    {
+      constant: true,
+      inputs: [
+        {
+          name: "_owner",
+          type: "address"
+        },
+        {
+          name: "_spender",
+          type: "address"
+        }
+      ],
+      name: "allowance",
+      outputs: [
+        {
+          name: "",
+          type: "uint256"
+        }
+      ],
+      payable: false,
+      stateMutability: "view",
+      type: "function"
+    }
+  ];
+  var AdapterContext = class _AdapterContext {
+    static _instance;
+    _adapter;
+    constructor() {}
+    static getInstance() {
+      if (!_AdapterContext._instance) {
+        _AdapterContext._instance = new _AdapterContext;
+      }
+      return _AdapterContext._instance;
+    }
+    setAdapter(adapter) {
+      this._adapter = adapter;
+    }
+    getAdapter() {
+      if (!this._adapter) {
+        throw new Error("Provider adapter is not configurated. Configure with CowSdk or using AdapterContext.getInstance().setAdapter()");
+      }
+      return this._adapter;
+    }
+  };
+  function getGlobalAdapter() {
+    return AdapterContext.getInstance().getAdapter();
+  }
+  function setGlobalAdapter(adapter) {
+    const instance = AdapterContext.getInstance();
+    instance.setAdapter(adapter);
+  }
+  var ContractFactory = class {
+    static createEthFlowContract(address, signer) {
+      const adapter = getGlobalAdapter();
+      return {
+        address,
+        estimateGas: {
+          createOrder: async (order, options) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(EthFlowAbi, "createOrder", [order]),
+              value: options?.value || "0"
+            };
+            return await signer.estimateGas(txParams);
+          },
+          invalidateOrder: async (order) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(EthFlowAbi, "invalidateOrder", [order])
+            };
+            return await signer.estimateGas(txParams);
+          },
+          orders: async (orderHash) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(EthFlowAbi, "orders", [orderHash])
+            };
+            return await signer.estimateGas(txParams);
+          }
+        },
+        interface: {
+          encodeFunctionData: (functionName, args) => {
+            return adapter.utils.encodeFunction(EthFlowAbi, functionName, args);
+          },
+          decodeFunctionData: (functionName, data) => {
+            return adapter.utils.decodeFunctionData(EthFlowAbi, functionName, data);
+          },
+          parseLog(event) {
+            return adapter.utils.createInterface(EthFlowAbi).parseLog(event);
+          },
+          getEventTopic(eventFragment) {
+            return adapter.utils.createInterface(EthFlowAbi).getEventTopic(eventFragment);
+          }
+        },
+        functions: {
+          createOrder: async (order, options) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(EthFlowAbi, "createOrder", [order]),
+              value: options?.value || "0"
+            };
+            return await signer.sendTransaction(txParams);
+          },
+          invalidateOrder: async (order) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(EthFlowAbi, "invalidateOrder", [order])
+            };
+            return await signer.sendTransaction(txParams);
+          },
+          orders: async (orderHash) => {
+            return await adapter.readContract({
+              address,
+              abi: EthFlowAbi,
+              functionName: "orders",
+              args: [orderHash]
+            });
+          }
+        },
+        createOrder: async (order, options) => {
+          const txParams = {
+            to: address,
+            data: adapter.utils.encodeFunction(EthFlowAbi, "createOrder", [order]),
+            value: options?.value || "0"
+          };
+          return await signer.sendTransaction(txParams);
+        },
+        invalidateOrder: async (order) => {
+          const txParams = {
+            to: address,
+            data: adapter.utils.encodeFunction(EthFlowAbi, "invalidateOrder", [order])
+          };
+          return await signer.sendTransaction(txParams);
+        },
+        orders: async (orderHash) => {
+          return await adapter.readContract({
+            address,
+            abi: EthFlowAbi,
+            functionName: "orders",
+            args: [orderHash]
+          });
+        }
+      };
+    }
+    static createSettlementContract(address, signer) {
+      const adapter = getGlobalAdapter();
+      return {
+        address,
+        estimateGas: {
+          setPreSignature: async (orderUid, signed) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(GPV2SettlementAbi, "setPreSignature", [orderUid, signed])
+            };
+            return await signer.estimateGas(txParams);
+          },
+          invalidateOrder: async (orderUid) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(GPV2SettlementAbi, "invalidateOrder", [orderUid])
+            };
+            return await signer.estimateGas(txParams);
+          },
+          domainSeparator: async () => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(GPV2SettlementAbi, "domainSeparator", [])
+            };
+            return await signer.estimateGas(txParams);
+          }
+        },
+        interface: {
+          encodeFunctionData: (functionName, args) => {
+            return adapter.utils.encodeFunction(GPV2SettlementAbi, functionName, args);
+          },
+          decodeFunctionData: (functionName, data) => {
+            return adapter.utils.decodeFunctionData(GPV2SettlementAbi, functionName, data);
+          },
+          parseLog(event) {
+            return adapter.utils.createInterface(GPV2SettlementAbi).parseLog(event);
+          },
+          getEventTopic(eventFragment) {
+            return adapter.utils.createInterface(GPV2SettlementAbi).getEventTopic(eventFragment);
+          }
+        },
+        functions: {
+          setPreSignature: async (orderUid, signed) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(GPV2SettlementAbi, "setPreSignature", [orderUid, signed])
+            };
+            return await signer.sendTransaction(txParams);
+          },
+          invalidateOrder: async (orderUid) => {
+            const txParams = {
+              to: address,
+              data: adapter.utils.encodeFunction(GPV2SettlementAbi, "invalidateOrder", [orderUid])
+            };
+            return await signer.sendTransaction(txParams);
+          },
+          domainSeparator: async () => {
+            return await adapter.readContract({
+              address,
+              abi: GPV2SettlementAbi,
+              functionName: "domainSeparator",
+              args: []
+            });
+          }
+        },
+        setPreSignature: async (orderUid, signed) => {
+          const txParams = {
+            to: address,
+            data: adapter.utils.encodeFunction(GPV2SettlementAbi, "setPreSignature", [orderUid, signed])
+          };
+          return await signer.sendTransaction(txParams);
+        },
+        invalidateOrder: async (orderUid) => {
+          const txParams = {
+            to: address,
+            data: adapter.utils.encodeFunction(GPV2SettlementAbi, "invalidateOrder", [orderUid])
+          };
+          return await signer.sendTransaction(txParams);
+        },
+        domainSeparator: async () => {
+          return await adapter.readContract({
+            address,
+            abi: GPV2SettlementAbi,
+            functionName: "domainSeparator",
+            args: []
+          });
+        }
+      };
+    }
+  };
+  var AbstractSigner = class {
+  };
+  var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+  var ZERO = BigInt(0);
+  var ONE = BigInt(1);
+  var ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+  var MAX_UINT32 = BigInt(2) ** BigInt(32) - BigInt(1);
+  var CowError = class extends Error {
+    error_code;
+    constructor(message, error_code) {
+      super(message);
+      this.error_code = error_code;
+    }
+  };
+  var logEnabled = false;
+  function log(text) {
+    if (!logEnabled)
+      return;
+    console.log(`[COW SDK] ${text}`);
+  }
+  function enableLogging(enabled) {
+    logEnabled = enabled;
+  }
+  var jsonWithBigintReplacer = (_key, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (typeof value === "object" && value !== null && "_isBigNumber" in value) {
+      return value.toString();
+    }
+    return value;
+  };
+  var SCALE = 1e6;
+  var SCALE_BIGINT = BigInt(SCALE);
+  var BPS_FACTOR = 10000n;
+  function percentageToBps(percentage) {
+    const bps = typeof percentage === "bigint" ? Number(percentage * BPS_FACTOR) : percentage * Number(BPS_FACTOR);
+    return Math.round(bps);
+  }
+  function bpsToPercentage(bps) {
+    return bps / 100;
+  }
+  function applyPercentage(value, percentage) {
+    const valueMultiplied = value * BigInt(Math.floor(percentage * SCALE)) / SCALE_BIGINT;
+    const roundUp = valueMultiplied % 100n >= 50n ? 1n : 0n;
+    return valueMultiplied / 100n + roundUp;
+  }
+  function normalizePrivateKey(privateKey) {
+    if (!privateKey || typeof privateKey !== "string") {
+      throw new CowError("Private key must be a non-empty string");
+    }
+    const cleanKey = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+    if (!/^[a-fA-F0-9]{64}$/.test(cleanKey)) {
+      throw new CowError("Invalid private key format: must be exactly 64 hexadecimal characters (with or without 0x prefix)");
+    }
+    return `0x${cleanKey}`;
+  }
+  function isValidPrivateKey(privateKey) {
+    try {
+      normalizePrivateKey(privateKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  var MemoryStorage = class {
+    storage = /* @__PURE__ */ new Map;
+    getItem(key) {
+      return this.storage.get(key) ?? null;
+    }
+    setItem(key, value) {
+      this.storage.set(key, value);
+    }
+    removeItem(key) {
+      this.storage.delete(key);
+    }
+    size(prefix) {
+      if (!prefix)
+        return this.storage.size;
+      let count = 0;
+      for (const key of this.storage.keys()) {
+        if (key.startsWith(prefix))
+          count++;
+      }
+      return count;
+    }
+    clear(prefix) {
+      if (!prefix) {
+        this.storage.clear();
+        return;
+      }
+      const keysToDelete = [];
+      for (const key of this.storage.keys()) {
+        if (key.startsWith(prefix))
+          keysToDelete.push(key);
+      }
+      keysToDelete.forEach((key) => this.storage.delete(key));
+    }
+  };
+  var LocalStorageWrapper = class {
+    fallback = new MemoryStorage;
+    getItem(key) {
+      try {
+        return typeof localStorage !== "undefined" ? localStorage.getItem(key) : this.fallback.getItem(key);
+      } catch {
+        return this.fallback.getItem(key);
+      }
+    }
+    setItem(key, value) {
+      try {
+        if (typeof localStorage !== "undefined") {
+          localStorage.setItem(key, value);
+        } else {
+          this.fallback.setItem(key, value);
+        }
+      } catch {
+        this.fallback.setItem(key, value);
+      }
+    }
+    removeItem(key) {
+      try {
+        if (typeof localStorage !== "undefined") {
+          localStorage.removeItem(key);
+        } else {
+          this.fallback.removeItem(key);
+        }
+      } catch {
+        this.fallback.removeItem(key);
+      }
+    }
+  };
+  var DEFAULT_KEY_PREFIX = "ttl-cache";
+  var DEFAULT_TTL = 2 * 60 * 1000;
+  var TTLCache = class {
+    storage;
+    keyPrefix;
+    ttl;
+    keys = /* @__PURE__ */ new Set;
+    get isMemoryStorage() {
+      return this.storage instanceof MemoryStorage;
+    }
+    constructor(keyPrefix = DEFAULT_KEY_PREFIX, useLocalStorage = true, ttl = DEFAULT_TTL) {
+      this.keyPrefix = keyPrefix;
+      this.ttl = ttl;
+      this.storage = useLocalStorage ? new LocalStorageWrapper : new MemoryStorage;
+      if (useLocalStorage && typeof localStorage === "undefined") {
+        this.storage = new MemoryStorage;
+      }
+    }
+    set(key, value) {
+      if (this.ttl <= 0)
+        return;
+      const entry = {
+        value,
+        timestamp: Date.now(),
+        ttl: this.ttl
+      };
+      const storageKey = this.getStorageKey(key);
+      try {
+        this.storage.setItem(storageKey, JSON.stringify(entry));
+      } catch (error) {
+        console.warn("TTLCache: Failed to store cache entry", error);
+      }
+      this.keys.add(storageKey);
+    }
+    get(key) {
+      const storageKey = this.getStorageKey(key);
+      const item = this.storage.getItem(storageKey);
+      if (!item) {
+        return;
+      }
+      try {
+        const entry = JSON.parse(item);
+        const now = Date.now();
+        if (now - entry.timestamp > entry.ttl) {
+          this.storage.removeItem(storageKey);
+          this.keys.delete(storageKey);
+          return;
+        }
+        return entry.value;
+      } catch (error) {
+        console.warn("TTLCache: Failed to parse cache entry", error);
+        this.storage.removeItem(storageKey);
+        this.keys.delete(storageKey);
+        return;
+      }
+    }
+    delete(key) {
+      const storageKey = this.getStorageKey(key);
+      this.storage.removeItem(storageKey);
+      this.keys.delete(storageKey);
+    }
+    clear() {
+      const prefix = this.keyPrefix + ":";
+      if (this.isMemoryStorage) {
+        this.storage.clear(prefix);
+        this.keys.clear();
+        return;
+      }
+      if (typeof localStorage !== "undefined") {
+        try {
+          const keysToDelete = [];
+          for (let i = 0;i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key && key.startsWith(prefix)) {
+              keysToDelete.push(key);
+            }
+          }
+          keysToDelete.forEach((key) => localStorage.removeItem(key));
+        } catch {
+          console.warn("TTLCache: Failed to clear localStorage cache");
+        }
+      }
+      for (const key of Array.from(this.keys)) {
+        try {
+          this.storage.removeItem(key);
+        } catch (error) {
+          console.warn("TTLCache: Failed to remove cache key", error);
+        }
+        this.keys.delete(key);
+      }
+    }
+    size() {
+      const prefix = this.keyPrefix + ":";
+      if (this.isMemoryStorage && this.storage instanceof MemoryStorage) {
+        return this.storage.size(prefix);
+      }
+      if (typeof localStorage === "undefined") {
+        return this.keys.size;
+      }
+      if (typeof localStorage !== "undefined") {
+        try {
+          let count = 0;
+          for (let i = 0;i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key && key.startsWith(prefix)) {
+              count++;
+            }
+          }
+          return count;
+        } catch {
+          return this.keys.size;
+        }
+      }
+      return this.keys.size;
+    }
+    cleanup() {
+      const prefix = this.keyPrefix + ":";
+      if (typeof localStorage !== "undefined") {
+        try {
+          const keysToDelete = [];
+          const now2 = Date.now();
+          for (let i = 0;i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key && key.startsWith(prefix)) {
+              const item = localStorage.getItem(key);
+              if (item) {
+                try {
+                  const entry = JSON.parse(item);
+                  if (now2 - entry.timestamp > entry.ttl) {
+                    keysToDelete.push(key);
+                  }
+                } catch {
+                  keysToDelete.push(key);
+                }
+              }
+            }
+          }
+          keysToDelete.forEach((key) => localStorage.removeItem(key));
+        } catch {
+          console.warn("TTLCache: Failed to cleanup expired entries");
+        }
+      }
+      const now = Date.now();
+      for (const key of Array.from(this.keys)) {
+        const item = this.storage.getItem(key);
+        if (!item) {
+          this.keys.delete(key);
+          continue;
+        }
+        try {
+          const entry = JSON.parse(item);
+          if (now - entry.timestamp > entry.ttl) {
+            this.storage.removeItem(key);
+            this.keys.delete(key);
+          }
+        } catch {
+          this.storage.removeItem(key);
+          this.keys.delete(key);
+        }
+      }
+    }
+    getStorageKey(key) {
+      return `${this.keyPrefix}:${key}`;
+    }
+  };
+});
+
+// src/rift-api-client.ts
+var BTC = {
+  chain: { kind: "BITCOIN" },
+  token: { kind: "NATIVE", decimals: 8 }
+};
+var CBBTC_ETHEREUM = {
+  chain: { kind: "EVM", chainId: 1 },
+  token: {
+    kind: "TOKEN",
+    address: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+    decimals: 8
+  }
+};
+var CBBTC_BASE = {
+  chain: { kind: "EVM", chainId: 8453 },
+  token: {
+    kind: "TOKEN",
+    address: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+    decimals: 8
+  }
+};
+
+class SwapRouterApiError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "SwapRouterApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class SwapRouterClient {
+  baseUrl;
+  fetch;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.fetch = options.fetch ?? globalThis.fetch;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await this.fetch(url, {
+      method,
+      headers: body ? { "Content-Type": "application/json" } : undefined,
+      body: body ? JSON.stringify(body) : undefined
+    });
+    const text = await response.text();
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      if (!response.ok) {
+        throw new SwapRouterApiError(text || `Request failed with status ${response.status}`, response.status);
+      }
+      throw new SwapRouterApiError(`Invalid JSON response: ${text}`, response.status);
+    }
+    if (!response.ok) {
+      throw new SwapRouterApiError(data.error ?? `Request failed with status ${response.status}`, response.status, data);
+    }
+    return data;
+  }
+  async health() {
+    return this.request("GET", "/health");
+  }
+  async status() {
+    return this.request("GET", "/status");
+  }
+  async quote(request) {
+    return this.request("POST", "/quote", request);
+  }
+  async createOrder(request) {
+    return this.request("POST", "/order", request);
+  }
+  async getOrder(orderId) {
+    return this.request("GET", `/order/${orderId}`);
+  }
+}
+// src/router.ts
+import { match, P } from "ts-pattern";
+var CBBTC_ADDRESS = "0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf";
+var isBitcoin = (currency) => currency.chain.kind === "BITCOIN";
+var isCbBtc = (currency) => currency.chain.kind === "EVM" && currency.token.kind === "TOKEN" && currency.token.address.toLowerCase() === CBBTC_ADDRESS;
+var isEvmToken = (currency) => currency.chain.kind === "EVM";
+function detectRoute(from, to) {
+  return match({ from, to }).with({ from: P.when(isCbBtc), to: P.when(isBitcoin) }, () => ({
+    type: "direct_rift",
+    direction: "to_btc"
+  })).with({ from: P.when(isBitcoin), to: P.when(isEvmToken) }, () => ({
+    type: "direct_rift",
+    direction: "from_btc"
+  })).with({
+    from: P.when((c) => isEvmToken(c) && !isCbBtc(c)),
+    to: P.when(isBitcoin)
+  }, ({ from: from2 }) => {
+    if (from2.chain.kind !== "EVM") {
+      throw new Error("Expected EVM chain");
+    }
+    return {
+      type: "cowswap_then_rift",
+      evmChainId: from2.chain.chainId
+    };
+  }).otherwise(() => {
+    throw new Error("Invalid swap: one side must be BTC");
+  });
+}
+function getCbBtcAddress(chainId) {
+  return CBBTC_ADDRESS;
+}
+var NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+function getTokenAddress(currency) {
+  if (currency.token.kind === "NATIVE") {
+    return NATIVE_TOKEN_ADDRESS;
+  }
+  return currency.token.address;
+}
+function isNativeToken(currency) {
+  return currency.token.kind === "NATIVE";
+}
+function getTokenDecimals(currency) {
+  return currency.token.decimals;
+}
+function getSupportedModes(from, to) {
+  const route = detectRoute(from, to);
+  if (route.type === "cowswap_then_rift") {
+    return { exactInput: true, exactOutput: true };
+  }
+  if (route.direction === "to_btc") {
+    return { exactInput: true, exactOutput: true };
+  }
+  if (isCbBtc(to)) {
+    return { exactInput: true, exactOutput: true };
+  }
+  return { exactInput: true, exactOutput: false };
+}
+// src/sdk.ts
+import { match as match2 } from "ts-pattern";
+import { erc20Abi } from "viem";
+
+// src/cowswap.ts
+var import_sdk_common = __toESM(require_dist(), 1);
+import { OrderKind } from "@cowprotocol/sdk-order-book";
+import { TradingSdk } from "@cowprotocol/sdk-trading";
+import { ViemAdapter } from "@cowprotocol/sdk-viem-adapter";
+function createCowSwapSdk(chainId, publicClient, walletClient) {
+  const adapter = new ViemAdapter({
+    provider: publicClient,
+    walletClient
+  });
+  import_sdk_common.setGlobalAdapter(adapter);
+  return new TradingSdk({
+    chainId,
+    appCode: "rift.trade"
+  }, {}, adapter);
+}
+var MAX_UINT256 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
+async function ensureCowSwapApproval(sdk, tokenAddress, ownerAddress, amount) {
+  const currentAllowance = await sdk.getCowProtocolAllowance({
+    tokenAddress,
+    owner: ownerAddress
+  });
+  if (currentAllowance >= BigInt(amount)) {
+    return false;
+  }
+  await sdk.approveCowProtocol({
+    tokenAddress,
+    amount: MAX_UINT256
+  });
+  return true;
+}
+async function getCowSwapQuote(sdk, params) {
+  const { quoteResults, postSwapOrderFromQuote } = await sdk.getQuote({
+    kind: params.kind === "SELL" ? OrderKind.SELL : OrderKind.BUY,
+    sellToken: params.sellToken,
+    sellTokenDecimals: params.sellTokenDecimals,
+    buyToken: params.buyToken,
+    buyTokenDecimals: params.buyTokenDecimals,
+    amount: params.amount,
+    receiver: params.receiver,
+    slippageBps: params.slippageBps
+  });
+  const validTo = quoteResults.quoteResponse.quote.validTo;
+  const expiresAt = new Date(validTo * 1000);
+  const quote = {
+    quoteId: quoteResults.quoteResponse.id?.toString() ?? "",
+    buyAmount: quoteResults.amountsAndCosts.afterSlippage.buyAmount.toString(),
+    sellAmount: quoteResults.amountsAndCosts.afterSlippage.sellAmount.toString(),
+    feeAmount: quoteResults.amountsAndCosts.costs.networkFee.amountInSellCurrency.toString(),
+    expiresAt
+  };
+  return {
+    quote,
+    postOrder: async () => {
+      const { orderId } = await postSwapOrderFromQuote();
+      return orderId;
+    }
+  };
+}
+
+// src/swap-id.ts
+function encodeSwapId(data) {
+  let raw;
+  if (data.type === "rift") {
+    raw = data.chained ? `r|${data.riftOrderId}|c` : `r|${data.riftOrderId}`;
+  } else {
+    raw = `c|${data.cowOrderId}|${data.riftOrderId}`;
+  }
+  return toBase64Url(raw);
+}
+function decodeSwapId(encoded) {
+  const raw = fromBase64Url(encoded);
+  const parts = raw.split("|");
+  if (parts[0] === "r" && (parts.length === 2 || parts.length === 3)) {
+    return {
+      type: "rift",
+      riftOrderId: parts[1],
+      chained: parts[2] === "c"
+    };
+  }
+  if (parts[0] === "c" && parts.length === 3) {
+    return { type: "cowswap_rift", cowOrderId: parts[1], riftOrderId: parts[2] };
+  }
+  throw new Error(`Invalid swap ID format: ${encoded}`);
+}
+function toBase64Url(str) {
+  return Buffer.from(str, "utf-8").toString("base64url");
+}
+function fromBase64Url(str) {
+  return Buffer.from(str, "base64url").toString("utf-8");
+}
+
+// src/sdk.ts
+class RiftSdk {
+  riftClient;
+  publicClient;
+  walletClient;
+  sendBitcoinFn;
+  constructor(options) {
+    this.riftClient = new SwapRouterClient({
+      baseUrl: options.apiUrl ?? "https://api.rift.trade"
+    });
+    this.publicClient = options.publicClient;
+    this.walletClient = options.walletClient;
+    this.sendBitcoinFn = options.sendBitcoin;
+  }
+  async getQuote(params) {
+    const route = detectRoute(params.from, params.to);
+    return match2(route).with({ type: "direct_rift", direction: "to_btc" }, () => this.getDirectRiftQuote(params, "to_btc")).with({ type: "direct_rift", direction: "from_btc" }, () => this.getDirectRiftQuote(params, "from_btc")).with({ type: "cowswap_then_rift" }, (r) => this.getCowswapThenRiftQuote(params, r.evmChainId)).exhaustive();
+  }
+  async getDirectRiftQuote(params, direction) {
+    const quoteRequest = {
+      type: params.mode === "exact_input" ? "EXACT_INPUT" : "EXACT_OUTPUT",
+      from: params.from,
+      to: params.to,
+      amount: params.amount
+    };
+    const riftQuote = await this.riftClient.quote(quoteRequest);
+    const quote = this.buildQuoteResult(riftQuote, params);
+    const isChained = direction === "from_btc" && !isCbBtc(params.to);
+    return {
+      quote,
+      executeSwap: async () => {
+        const refundAddress = params.refundAddress ?? await this.getRefundAddress(params);
+        const swap = await this.riftClient.createOrder({
+          id: riftQuote.id,
+          userDestinationAddress: params.destinationAddress,
+          refundAddress
+        });
+        await this.executeDeposit(swap, params, direction);
+        return this.buildSwapResult(swap, { chained: isChained });
+      }
+    };
+  }
+  async getCowswapThenRiftQuote(params, evmChainId) {
+    const cbBtcAddress = getCbBtcAddress(evmChainId);
+    const cbBtcCurrency = {
+      chain: { kind: "EVM", chainId: evmChainId },
+      token: { kind: "TOKEN", address: cbBtcAddress, decimals: 8 }
+    };
+    if (params.mode === "exact_input") {
+      return this.getCowswapThenRiftExactInput(params, evmChainId, cbBtcAddress, cbBtcCurrency);
+    } else {
+      return this.getCowswapThenRiftExactOutput(params, evmChainId, cbBtcAddress, cbBtcCurrency);
+    }
+  }
+  async getCowswapThenRiftExactInput(params, evmChainId, cbBtcAddress, cbBtcCurrency) {
+    const cowSdk = createCowSwapSdk(evmChainId, this.publicClient, this.walletClient);
+    const sellToken = getTokenAddress(params.from);
+    const { quote: cowQuote } = await getCowSwapQuote(cowSdk, {
+      sellToken,
+      buyToken: cbBtcAddress,
+      amount: params.amount,
+      sellTokenDecimals: getTokenDecimals(params.from),
+      buyTokenDecimals: 8,
+      kind: "SELL",
+      slippageBps: params.preswapSlippageBps
+    });
+    const riftQuote = await this.riftClient.quote({
+      type: "EXACT_INPUT",
+      from: cbBtcCurrency,
+      to: BTC,
+      amount: cowQuote.buyAmount
+    });
+    const quote = this.buildCombinedQuoteResult(params, cowQuote, riftQuote);
+    return {
+      quote,
+      executeSwap: () => this.executeCowswapThenRift(params, riftQuote, evmChainId, cbBtcAddress, sellToken)
+    };
+  }
+  async getCowswapThenRiftExactOutput(params, evmChainId, cbBtcAddress, cbBtcCurrency) {
+    const cowSdk = createCowSwapSdk(evmChainId, this.publicClient, this.walletClient);
+    const sellToken = getTokenAddress(params.from);
+    const riftQuote = await this.riftClient.quote({
+      type: "EXACT_OUTPUT",
+      from: cbBtcCurrency,
+      to: BTC,
+      amount: params.amount
+    });
+    const { quote: cowQuote } = await getCowSwapQuote(cowSdk, {
+      sellToken,
+      buyToken: cbBtcAddress,
+      amount: riftQuote.from.amount,
+      sellTokenDecimals: getTokenDecimals(params.from),
+      buyTokenDecimals: 8,
+      kind: "BUY",
+      slippageBps: params.preswapSlippageBps
+    });
+    const quote = this.buildCombinedQuoteResult(params, cowQuote, riftQuote);
+    return {
+      quote,
+      executeSwap: () => this.executeCowswapThenRift(params, riftQuote, evmChainId, cbBtcAddress, sellToken)
+    };
+  }
+  async executeCowswapThenRift(params, riftQuote, evmChainId, cbBtcAddress, sellToken) {
+    const refundAddress = params.refundAddress ?? await this.getRefundAddress(params);
+    const swap = await this.riftClient.createOrder({
+      id: riftQuote.id,
+      userDestinationAddress: params.destinationAddress,
+      refundAddress
+    });
+    const cowSdk = createCowSwapSdk(evmChainId, this.publicClient, this.walletClient);
+    const sellAmount = params.mode === "exact_input" ? params.amount : riftQuote.from.amount;
+    if (!isNativeToken(params.from)) {
+      const ownerAddress = await this.getAddress();
+      await ensureCowSwapApproval(cowSdk, sellToken, ownerAddress, sellAmount);
+    }
+    const { postOrder } = await getCowSwapQuote(cowSdk, {
+      sellToken,
+      buyToken: cbBtcAddress,
+      amount: sellAmount,
+      sellTokenDecimals: getTokenDecimals(params.from),
+      buyTokenDecimals: 8,
+      kind: params.mode === "exact_input" ? "SELL" : "BUY",
+      receiver: swap.deposit_vault_address,
+      slippageBps: params.preswapSlippageBps
+    });
+    const cowOrderId = await postOrder();
+    return this.buildSwapResult(swap, { cowOrderId });
+  }
+  buildQuoteResult(riftQuote, params) {
+    return {
+      quoteId: riftQuote.id,
+      from: {
+        currency: params.from,
+        amount: riftQuote.from.amount
+      },
+      to: {
+        currency: params.to,
+        amount: riftQuote.to.amount
+      },
+      fees: {
+        protocol: riftQuote.fees.raw.protocolFeeBps.toString(),
+        liquidity: riftQuote.fees.raw.liquidityFeeBps.toString(),
+        network: riftQuote.fees.raw.networkFeeSats,
+        totalUsd: riftQuote.fees.usd.marketMaker + riftQuote.fees.usd.protocol + riftQuote.fees.usd.network
+      },
+      expiresAt: new Date(riftQuote.expiresAt)
+    };
+  }
+  buildCombinedQuoteResult(params, cowQuote, riftQuote) {
+    const earliestExpiry = new Date(Math.min(cowQuote.expiresAt.getTime(), new Date(riftQuote.expiresAt).getTime()));
+    const fromAmount = params.mode === "exact_input" ? params.amount : cowQuote.sellAmount;
+    return {
+      quoteId: `${cowQuote.quoteId}:${riftQuote.id}`,
+      from: {
+        currency: params.from,
+        amount: fromAmount
+      },
+      to: {
+        currency: params.to,
+        amount: riftQuote.to.amount
+      },
+      fees: {
+        protocol: riftQuote.fees.raw.protocolFeeBps.toString(),
+        liquidity: riftQuote.fees.raw.liquidityFeeBps.toString(),
+        network: riftQuote.fees.raw.networkFeeSats,
+        totalUsd: riftQuote.fees.usd.marketMaker + riftQuote.fees.usd.protocol + riftQuote.fees.usd.network
+      },
+      expiresAt: earliestExpiry
+    };
+  }
+  buildSwapResult(swap, options) {
+    const { cowOrderId, preswap, chained } = options ?? {};
+    const swapId = cowOrderId ? encodeSwapId({ type: "cowswap_rift", cowOrderId, riftOrderId: swap.id }) : encodeSwapId({ type: "rift", riftOrderId: swap.id, chained });
+    return {
+      swapId,
+      status: this.mapStatus(swap.status, chained),
+      rift: swap,
+      preswap
+    };
+  }
+  async executeDeposit(swap, params, direction) {
+    if (direction === "from_btc") {
+      await this.sendBitcoinFn({
+        recipient: swap.deposit_vault_address,
+        amountSats: swap.quote.from.amount
+      });
+    } else {
+      await this.transferErc20(getTokenAddress(params.from), swap.deposit_vault_address, swap.quote.from.amount);
+    }
+  }
+  async transferErc20(tokenAddress, to, amount) {
+    const address = await this.getAddress();
+    const hash = await this.walletClient.writeContract({
+      account: address,
+      address: tokenAddress,
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [to, BigInt(amount)],
+      chain: this.walletClient.chain
+    });
+    return hash;
+  }
+  async getAddress() {
+    const addresses = await this.walletClient.getAddresses();
+    const address = addresses[0];
+    if (!address) {
+      throw new Error("No address available in wallet");
+    }
+    return address;
+  }
+  async getRefundAddress(params) {
+    if (params.from.chain.kind === "BITCOIN") {
+      throw new Error("refundAddress is required for BTC swaps (Bitcoin refund address)");
+    }
+    return this.getAddress();
+  }
+  mapStatus(status, isChained) {
+    return match2(status).with("waiting_user_deposit_initiated", () => "pending_deposit").with("waiting_user_deposit_confirmed", () => "deposit_detected").with("waiting_mm_deposit_initiated", () => "processing").with("waiting_mm_deposit_confirmed", () => isChained ? "processing" : "funds_received").with("settling", () => isChained ? "swapping" : "settling").with("settled", () => "completed").with("failed", () => "failed").with("refunding_user", () => "refunding").exhaustive();
+  }
+  async getSwapStatus(swapId) {
+    const decoded = decodeSwapId(swapId);
+    if (decoded.type === "rift") {
+      const rift2 = await this.riftClient.getOrder(decoded.riftOrderId);
+      return {
+        swapId,
+        status: this.mapStatus(rift2.status, decoded.chained),
+        rift: rift2
+      };
+    }
+    const [preswap, rift] = await Promise.all([
+      this.getCowSwapOrder(decoded.cowOrderId),
+      this.riftClient.getOrder(decoded.riftOrderId)
+    ]);
+    const status = this.computeOverallStatus(preswap.status, rift.status);
+    return {
+      swapId,
+      status,
+      rift,
+      preswap
+    };
+  }
+  async getCowSwapOrder(orderId) {
+    const chains = ["mainnet", "base"];
+    const maxRetries = 3;
+    const retryDelayMs = 2000;
+    for (let attempt = 0;attempt < maxRetries; attempt++) {
+      const results = await Promise.allSettled(chains.map((chain) => this.fetchCowSwapOrder(chain, orderId)));
+      const success = results.find((result) => result.status === "fulfilled");
+      if (success)
+        return success.value;
+      if (attempt === maxRetries - 1) {
+        const reasons = results.map((result) => result.status === "rejected" ? result.reason?.message ?? String(result.reason) : "unknown failure").join("; ");
+        throw new Error(`Failed to fetch CowSwap order ${orderId}: ${reasons}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+    }
+    throw new Error(`Failed to fetch CowSwap order ${orderId}`);
+  }
+  async fetchCowSwapOrder(chain, orderId) {
+    const response = await fetch(`https://api.cow.fi/${chain}/api/v1/orders/${orderId}`);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} from CowSwap ${chain} for order ${orderId}`);
+    }
+    return response.json();
+  }
+  computeOverallStatus(cowStatus, riftStatus) {
+    if (cowStatus === "cancelled" || cowStatus === "expired") {
+      return "failed";
+    }
+    if (cowStatus === "presignaturePending" || cowStatus === "open") {
+      return "pending_deposit";
+    }
+    return this.mapStatus(riftStatus);
+  }
+}
+export {
+  getSupportedModes,
+  encodeSwapId,
+  detectRoute,
+  decodeSwapId,
+  RiftSdk,
+  CBBTC_ETHEREUM,
+  CBBTC_BASE,
+  BTC
+};