@sardis/ramp 0.1.0

package/dist/index.cjs

@@ -0,0 +1,667 @@
+"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 index_exports = {};
+__export(index_exports, {
+  PolicyViolation: () => PolicyViolation,
+  RampError: () => RampError,
+  SardisFiatRamp: () => SardisFiatRamp,
+  SardisOnramper: () => SardisOnramper,
+  createOnramper: () => createOnramper
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var PolicyViolation = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PolicyViolation";
+  }
+};
+var RampError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.name = "RampError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/ramp.ts
+var DEFAULT_BRIDGE_API_URL = "https://api.bridge.xyz/v0";
+var DEFAULT_BRIDGE_SANDBOX_URL = "https://api.sandbox.bridge.xyz/v0";
+var DEFAULT_SARDIS_API_URL = "https://api.sardis.sh/v2";
+var SardisFiatRamp = class {
+  constructor(config) {
+    if (!config.sardisKey || config.sardisKey.trim() === "") {
+      throw new RampError("Sardis API key is required", "INVALID_CONFIG");
+    }
+    if (!config.bridgeKey || config.bridgeKey.trim() === "") {
+      throw new RampError("Bridge API key is required", "INVALID_CONFIG");
+    }
+    this.sardisKey = config.sardisKey;
+    this.bridgeKey = config.bridgeKey;
+    this.bridgeUrl = config.bridgeUrl ?? (config.environment === "production" ? DEFAULT_BRIDGE_API_URL : DEFAULT_BRIDGE_SANDBOX_URL);
+    this.sardisUrl = config.sardisUrl ?? DEFAULT_SARDIS_API_URL;
+  }
+  async sardisRequest(method, path, body) {
+    const response = await fetch(`${this.sardisUrl}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.sardisKey}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new RampError(
+        error.message || "Sardis API error",
+        error.code || "SARDIS_ERROR",
+        error
+      );
+    }
+    return response.json();
+  }
+  async bridgeRequest(method, path, body) {
+    const response = await fetch(`${this.bridgeUrl}${path}`, {
+      method,
+      headers: {
+        "Api-Key": this.bridgeKey,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new RampError(
+        error.message || "Bridge API error",
+        error.code || "BRIDGE_ERROR",
+        error
+      );
+    }
+    return response.json();
+  }
+  async getWallet(walletId) {
+    return this.sardisRequest("GET", `/wallets/${walletId}`);
+  }
+  /**
+   * Fund a Sardis wallet from fiat sources.
+   *
+   * @example
+   * ```typescript
+   * const result = await ramp.fundWallet({
+   *   walletId: 'wallet_123',
+   *   amountUsd: 100,
+   *   method: 'bank'
+   * })
+   * console.log(result.achInstructions?.routingNumber)
+   * ```
+   */
+  async fundWallet(params) {
+    const wallet = await this.getWallet(params.walletId);
+    if (params.method === "crypto") {
+      return {
+        type: "crypto",
+        depositAddress: wallet.address,
+        chain: wallet.chain,
+        token: "USDC"
+      };
+    }
+    const transfer = await this.bridgeRequest("POST", "/transfers", {
+      amount: params.amountUsd.toString(),
+      on_behalf_of: params.walletId,
+      source: {
+        payment_rail: params.method === "bank" ? "ach" : "card",
+        currency: "usd"
+      },
+      destination: {
+        payment_rail: "ethereum",
+        currency: "usdc",
+        to_address: wallet.address,
+        chain: this.chainToBridge(wallet.chain)
+      }
+    });
+    let achInstructions;
+    let wireInstructions;
+    const instr = transfer.source_deposit_instructions;
+    if (instr?.payment_rail === "ach") {
+      achInstructions = {
+        accountNumber: instr.account_number,
+        routingNumber: instr.routing_number,
+        bankName: instr.bank_name,
+        accountHolder: instr.account_holder,
+        reference: instr.reference
+      };
+    } else if (instr?.payment_rail === "wire") {
+      wireInstructions = {
+        accountNumber: instr.account_number,
+        routingNumber: instr.routing_number,
+        swiftCode: instr.swift_code || "",
+        bankName: instr.bank_name,
+        bankAddress: instr.bank_address || "",
+        accountHolder: instr.account_holder,
+        reference: instr.reference
+      };
+    }
+    return {
+      type: "fiat",
+      paymentLink: transfer.hosted_url,
+      achInstructions,
+      wireInstructions,
+      estimatedArrival: transfer.estimated_completion_at ? new Date(transfer.estimated_completion_at) : void 0,
+      feePercent: transfer.fee ? parseFloat(transfer.fee.percent) : void 0,
+      transferId: transfer.id
+    };
+  }
+  /**
+   * Withdraw from Sardis wallet to bank account.
+   *
+   * @example
+   * ```typescript
+   * const result = await ramp.withdrawToBank({
+   *   walletId: 'wallet_123',
+   *   amountUsd: 50,
+   *   bankAccount: {
+   *     accountHolderName: 'John Doe',
+   *     accountNumber: '1234567890',
+   *     routingNumber: '021000021'
+   *   }
+   * })
+   * ```
+   */
+  async withdrawToBank(params) {
+    const wallet = await this.getWallet(params.walletId);
+    const policyCheck = await this.sardisRequest("POST", `/wallets/${params.walletId}/check-policy`, {
+      amount: params.amountUsd.toString(),
+      action: "withdrawal"
+    });
+    if (!policyCheck.allowed) {
+      throw new PolicyViolation(policyCheck.reason || "Policy violation");
+    }
+    const bridgeDeposit = await this.bridgeRequest(
+      "POST",
+      "/deposit-addresses",
+      {
+        chain: this.chainToBridge(wallet.chain),
+        currency: "usdc"
+      }
+    );
+    const tx = await this.sardisRequest(
+      "POST",
+      "/transactions",
+      {
+        wallet_id: params.walletId,
+        to: bridgeDeposit.address,
+        amount: params.amountUsd.toString(),
+        token: "USDC",
+        memo: "Withdrawal to bank"
+      }
+    );
+    const payout = await this.bridgeRequest("POST", "/payouts", {
+      amount: params.amountUsd.toString(),
+      currency: "usd",
+      source: {
+        tx_hash: tx.tx_hash,
+        chain: this.chainToBridge(wallet.chain)
+      },
+      destination: {
+        payment_rail: "ach",
+        account_holder_name: params.bankAccount.accountHolderName,
+        account_number: params.bankAccount.accountNumber,
+        routing_number: params.bankAccount.routingNumber,
+        account_type: params.bankAccount.accountType || "checking"
+      }
+    });
+    return {
+      txHash: tx.tx_hash,
+      payoutId: payout.id,
+      estimatedArrival: new Date(payout.estimated_completion_at),
+      fee: payout.fee ? parseFloat(payout.fee.amount) : 0,
+      status: "pending"
+    };
+  }
+  /**
+   * Pay merchant in USD from crypto wallet.
+   *
+   * @example
+   * ```typescript
+   * const result = await ramp.payMerchantFiat({
+   *   walletId: 'wallet_123',
+   *   amountUsd: 99.99,
+   *   merchant: {
+   *     name: 'ACME Corp',
+   *     bankAccount: { ... }
+   *   }
+   * })
+   * ```
+   */
+  async payMerchantFiat(params) {
+    const wallet = await this.getWallet(params.walletId);
+    const policyCheck = await this.sardisRequest("POST", `/wallets/${params.walletId}/check-policy`, {
+      amount: params.amountUsd.toString(),
+      merchant: params.merchant.name,
+      category: params.merchant.category
+    });
+    if (!policyCheck.allowed) {
+      throw new PolicyViolation(policyCheck.reason || "Policy violation");
+    }
+    if (policyCheck.requires_approval) {
+      const approval = await this.sardisRequest(
+        "POST",
+        `/wallets/${params.walletId}/request-approval`,
+        {
+          amount: params.amountUsd.toString(),
+          reason: `Payment to ${params.merchant.name}`
+        }
+      );
+      return {
+        status: "pending_approval",
+        approvalRequest: approval
+      };
+    }
+    const payment = await this.bridgeRequest("POST", "/payments", {
+      amount: params.amountUsd.toString(),
+      source: {
+        wallet_address: wallet.address,
+        chain: this.chainToBridge(wallet.chain),
+        currency: "usdc"
+      },
+      destination: {
+        payment_rail: "ach",
+        currency: "usd",
+        account_holder_name: params.merchant.bankAccount.accountHolderName,
+        account_number: params.merchant.bankAccount.accountNumber,
+        routing_number: params.merchant.bankAccount.routingNumber
+      }
+    });
+    return {
+      status: "completed",
+      paymentId: payment.id,
+      merchantReceived: params.amountUsd,
+      fee: payment.fee ? parseFloat(payment.fee.amount) : 0,
+      txHash: payment.source_tx_hash
+    };
+  }
+  /**
+   * Get status of a funding transfer.
+   */
+  async getFundingStatus(transferId) {
+    return this.bridgeRequest("GET", `/transfers/${transferId}`);
+  }
+  /**
+   * Get status of a bank withdrawal.
+   */
+  async getWithdrawalStatus(payoutId) {
+    return this.bridgeRequest("GET", `/payouts/${payoutId}`);
+  }
+  chainToBridge(chain) {
+    const mapping = {
+      base: "base",
+      polygon: "polygon",
+      ethereum: "ethereum",
+      arbitrum: "arbitrum",
+      optimism: "optimism"
+    };
+    return mapping[chain.toLowerCase()] || chain;
+  }
+};
+
+// src/onramper.ts
+var ONRAMPER_API_URL = "https://api.onramper.com";
+var ONRAMPER_WIDGET_URL = "https://buy.onramper.com";
+var DEFAULT_SARDIS_API_URL2 = "https://api.sardis.sh/v2";
+var SardisOnramper = class {
+  constructor(config) {
+    if (!config.apiKey || config.apiKey.trim() === "") {
+      throw new RampError("Onramper API key is required", "INVALID_CONFIG");
+    }
+    if (!config.sardisKey || config.sardisKey.trim() === "") {
+      throw new RampError("Sardis API key is required", "INVALID_CONFIG");
+    }
+    this.apiKey = config.apiKey;
+    this.sardisKey = config.sardisKey;
+    this.sardisUrl = config.sardisUrl ?? DEFAULT_SARDIS_API_URL2;
+    this.mode = config.mode ?? "sandbox";
+    this.defaultFiat = config.defaultFiat ?? "USD";
+    this.defaultCrypto = config.defaultCrypto ?? "USDC";
+  }
+  // ===========================================================================
+  // API Requests
+  // ===========================================================================
+  async onramperRequest(method, path, body) {
+    const response = await fetch(`${ONRAMPER_API_URL}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new RampError(
+        error.message || "Onramper API error",
+        error.code || "ONRAMPER_ERROR",
+        error
+      );
+    }
+    return response.json();
+  }
+  async sardisRequest(method, path, body) {
+    const response = await fetch(`${this.sardisUrl}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.sardisKey}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new RampError(
+        error.message || "Sardis API error",
+        error.code || "SARDIS_ERROR",
+        error
+      );
+    }
+    return response.json();
+  }
+  // ===========================================================================
+  // Supported Assets
+  // ===========================================================================
+  /**
+   * Get supported fiat currencies
+   */
+  async getSupportedFiats() {
+    const response = await this.onramperRequest("GET", "/supported/fiats");
+    return response.fiats.map((f) => ({
+      code: f.code,
+      name: f.name,
+      symbol: f.symbol,
+      minAmount: f.limits.min,
+      maxAmount: f.limits.max
+    }));
+  }
+  /**
+   * Get supported crypto assets
+   */
+  async getSupportedCryptos(network) {
+    const path = network ? `/supported/crypto?network=${encodeURIComponent(network)}` : "/supported/crypto";
+    const response = await this.onramperRequest("GET", path);
+    return response.crypto.map((c) => ({
+      code: c.code,
+      name: c.name,
+      network: c.network,
+      symbol: c.symbol,
+      decimals: c.decimals,
+      minAmount: c.limits.min,
+      maxAmount: c.limits.max
+    }));
+  }
+  /**
+   * Get supported payment methods for a country
+   */
+  async getSupportedPaymentMethods(country) {
+    const response = await this.onramperRequest("GET", `/supported/payment-methods?country=${encodeURIComponent(country)}`);
+    return response.paymentMethods;
+  }
+  // ===========================================================================
+  // Quotes
+  // ===========================================================================
+  /**
+   * Get quotes from all available providers
+   */
+  async getQuotes(params) {
+    const queryParams = new URLSearchParams({
+      source: params.sourceCurrency,
+      destination: params.destinationCurrency,
+      amount: params.amount.toString(),
+      type: params.type || "fiat"
+    });
+    if (params.paymentMethod) {
+      queryParams.set("paymentMethod", params.paymentMethod);
+    }
+    if (params.country) {
+      queryParams.set("country", params.country);
+    }
+    if (params.network) {
+      queryParams.set("network", params.network);
+    }
+    const response = await this.onramperRequest("GET", `/quotes?${queryParams.toString()}`);
+    return response.quotes;
+  }
+  /**
+   * Get the best quote (lowest total cost)
+   */
+  async getBestQuote(params) {
+    const quotes = await this.getQuotes(params);
+    if (quotes.length === 0) {
+      return null;
+    }
+    return quotes.sort((a, b) => b.destinationAmount - a.destinationAmount)[0] ?? null;
+  }
+  // ===========================================================================
+  // Widget Integration
+  // ===========================================================================
+  /**
+   * Generate widget URL for embedding or redirect
+   *
+   * @example
+   * ```typescript
+   * const url = onramper.getWidgetUrl({
+   *   walletAddress: '0x...',
+   *   fiatCurrency: 'USD',
+   *   cryptoCurrency: 'USDC',
+   *   fiatAmount: 100,
+   *   network: 'base',
+   * })
+   * window.open(url, '_blank')
+   * ```
+   */
+  getWidgetUrl(options) {
+    const params = new URLSearchParams();
+    params.set("apiKey", this.apiKey);
+    params.set("walletAddress", options.walletAddress);
+    params.set("defaultFiat", options.fiatCurrency || this.defaultFiat);
+    params.set("defaultCrypto", options.cryptoCurrency || this.defaultCrypto);
+    if (options.fiatAmount) {
+      params.set("fiatAmount", options.fiatAmount.toString());
+    }
+    if (options.cryptoAmount) {
+      params.set("cryptoAmount", options.cryptoAmount.toString());
+    }
+    if (options.network) {
+      params.set("network", this.mapNetwork(options.network));
+    }
+    if (options.paymentMethod) {
+      params.set("paymentMethod", options.paymentMethod);
+    }
+    if (options.color) {
+      params.set("color", options.color.replace("#", ""));
+    }
+    if (options.darkMode) {
+      params.set("darkMode", "true");
+    }
+    if (options.onlyProviders?.length) {
+      params.set("onlyProviders", options.onlyProviders.join(","));
+    }
+    if (options.excludeProviders?.length) {
+      params.set("excludeProviders", options.excludeProviders.join(","));
+    }
+    if (options.country) {
+      params.set("country", options.country);
+    }
+    if (options.language) {
+      params.set("language", options.language);
+    }
+    if (options.skipIntro) {
+      params.set("skipIntro", "true");
+    }
+    if (options.redirectUrl) {
+      params.set("redirectUrl", options.redirectUrl);
+    }
+    if (options.partnerContext) {
+      params.set("partnerContext", options.partnerContext);
+    }
+    if (this.mode === "sandbox") {
+      params.set("isTestMode", "true");
+    }
+    return `${ONRAMPER_WIDGET_URL}?${params.toString()}`;
+  }
+  /**
+   * Generate widget HTML for iframe embedding
+   */
+  getWidgetIframe(options) {
+    const url = this.getWidgetUrl(options);
+    const width = options.width || "400px";
+    const height = options.height || "600px";
+    return `<iframe
+  src="${url}"
+  width="${width}"
+  height="${height}"
+  frameborder="0"
+  allow="accelerometer; autoplay; camera; gyroscope; payment"
+  style="border-radius: 10px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);"
+></iframe>`;
+  }
+  // ===========================================================================
+  // Transaction Management
+  // ===========================================================================
+  /**
+   * Get transaction status by Onramper transaction ID
+   */
+  async getTransaction(transactionId) {
+    return this.onramperRequest(
+      "GET",
+      `/transactions/${transactionId}`
+    );
+  }
+  /**
+   * List transactions for a wallet address
+   */
+  async listTransactions(walletAddress, options) {
+    const params = new URLSearchParams({
+      walletAddress
+    });
+    if (options?.limit) {
+      params.set("limit", options.limit.toString());
+    }
+    if (options?.offset) {
+      params.set("offset", options.offset.toString());
+    }
+    if (options?.status) {
+      params.set("status", options.status);
+    }
+    const response = await this.onramperRequest("GET", `/transactions?${params.toString()}`);
+    return response.transactions;
+  }
+  // ===========================================================================
+  // Sardis Integration
+  // ===========================================================================
+  /**
+   * Fund a Sardis wallet via Onramper widget
+   *
+   * Returns a widget URL that, when used, will deposit crypto
+   * directly to the Sardis wallet.
+   */
+  async fundWallet(params) {
+    const wallet = await this.sardisRequest("GET", `/wallets/${params.walletId}`);
+    const widgetUrl = this.getWidgetUrl({
+      walletAddress: wallet.address,
+      network: wallet.chain,
+      fiatAmount: params.fiatAmount,
+      fiatCurrency: params.fiatCurrency,
+      cryptoCurrency: params.cryptoCurrency || "USDC",
+      paymentMethod: params.paymentMethod,
+      redirectUrl: params.redirectUrl,
+      partnerContext: `sardis:${wallet.id}`,
+      darkMode: true,
+      color: "FF6B35"
+      // Sardis orange
+    });
+    return {
+      widgetUrl,
+      walletAddress: wallet.address,
+      network: wallet.chain
+    };
+  }
+  /**
+   * Get best quote for funding a Sardis wallet
+   */
+  async getWalletFundingQuote(params) {
+    const wallet = await this.sardisRequest("GET", `/wallets/${params.walletId}`);
+    return this.getBestQuote({
+      sourceCurrency: params.fiatCurrency || this.defaultFiat,
+      destinationCurrency: "USDC",
+      amount: params.fiatAmount,
+      type: "fiat",
+      paymentMethod: params.paymentMethod,
+      network: wallet.chain
+    });
+  }
+  // ===========================================================================
+  // Webhooks
+  // ===========================================================================
+  /**
+   * Verify webhook signature from Onramper
+   */
+  verifyWebhookSignature(payload, signature, secret) {
+    const crypto = require("crypto");
+    const expectedSignature = crypto.createHmac("sha256", secret).update(payload).digest("hex");
+    return crypto.timingSafeEqual(
+      Buffer.from(signature),
+      Buffer.from(expectedSignature)
+    );
+  }
+  /**
+   * Parse webhook payload
+   */
+  parseWebhookPayload(payload) {
+    return JSON.parse(payload);
+  }
+  // ===========================================================================
+  // Helpers
+  // ===========================================================================
+  mapNetwork(chain) {
+    const mapping = {
+      base: "base",
+      polygon: "polygon",
+      ethereum: "ethereum",
+      arbitrum: "arbitrum",
+      optimism: "optimism",
+      avalanche: "avalanche",
+      bsc: "bsc",
+      solana: "solana"
+    };
+    return mapping[chain.toLowerCase()] || chain;
+  }
+};
+function createOnramper(config) {
+  return new SardisOnramper(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PolicyViolation,
+  RampError,
+  SardisFiatRamp,
+  SardisOnramper,
+  createOnramper
+});