@t402/cosmos 2.4.0

package/dist/cjs/index.js

@@ -0,0 +1,619 @@
+"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, {
+  COSMOS_CAIP2_NAMESPACE: () => COSMOS_CAIP2_NAMESPACE,
+  COSMOS_NETWORKS: () => COSMOS_NETWORKS,
+  DEFAULT_FEE_AMOUNT: () => DEFAULT_FEE_AMOUNT,
+  DEFAULT_GAS_LIMIT: () => DEFAULT_GAS_LIMIT,
+  DEFAULT_GAS_PRICE: () => DEFAULT_GAS_PRICE,
+  ExactDirectCosmosClient: () => ExactDirectCosmosClient,
+  ExactDirectCosmosFacilitator: () => ExactDirectCosmosFacilitator,
+  ExactDirectCosmosServer: () => ExactDirectCosmosServer,
+  MAX_TRANSACTION_AGE: () => MAX_TRANSACTION_AGE,
+  MSG_TYPE_SEND: () => MSG_TYPE_SEND,
+  NETWORK_REST_ENDPOINTS: () => NETWORK_REST_ENDPOINTS,
+  NETWORK_RPC_ENDPOINTS: () => NETWORK_RPC_ENDPOINTS,
+  NOBLE_BECH32_PREFIX: () => NOBLE_BECH32_PREFIX,
+  NOBLE_MAINNET_CAIP2: () => NOBLE_MAINNET_CAIP2,
+  NOBLE_MAINNET_REST: () => NOBLE_MAINNET_REST,
+  NOBLE_MAINNET_RPC: () => NOBLE_MAINNET_RPC,
+  NOBLE_TESTNET_CAIP2: () => NOBLE_TESTNET_CAIP2,
+  NOBLE_TESTNET_REST: () => NOBLE_TESTNET_REST,
+  NOBLE_TESTNET_RPC: () => NOBLE_TESTNET_RPC,
+  SCHEME_EXACT_DIRECT: () => SCHEME_EXACT_DIRECT,
+  TOKEN_REGISTRY: () => TOKEN_REGISTRY,
+  USDC_DENOM: () => USDC_DENOM,
+  extractNetworkId: () => extractNetworkId,
+  formatAmount: () => formatAmount,
+  getDefaultToken: () => getDefaultToken,
+  getNetworkTokens: () => getNetworkTokens,
+  getRestEndpoint: () => getRestEndpoint,
+  getRpcEndpoint: () => getRpcEndpoint,
+  getSupportedNetworks: () => getSupportedNetworks,
+  getTokenByDenom: () => getTokenByDenom,
+  getTokenConfig: () => getTokenConfig,
+  isNetworkSupported: () => isNetworkSupported,
+  isValidAddress: () => isValidAddress,
+  normalizeNetwork: () => normalizeNetwork,
+  toAtomicUnits: () => toAtomicUnits
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var NOBLE_MAINNET_CAIP2 = "cosmos:noble-1";
+var NOBLE_TESTNET_CAIP2 = "cosmos:grand-1";
+var COSMOS_NETWORKS = [NOBLE_MAINNET_CAIP2, NOBLE_TESTNET_CAIP2];
+var NOBLE_MAINNET_RPC = "https://noble-rpc.polkachu.com";
+var NOBLE_TESTNET_RPC = "https://rpc.testnet.noble.strange.love";
+var NOBLE_MAINNET_REST = "https://noble-api.polkachu.com";
+var NOBLE_TESTNET_REST = "https://api.testnet.noble.strange.love";
+var NETWORK_RPC_ENDPOINTS = {
+  [NOBLE_MAINNET_CAIP2]: NOBLE_MAINNET_RPC,
+  [NOBLE_TESTNET_CAIP2]: NOBLE_TESTNET_RPC
+};
+var NETWORK_REST_ENDPOINTS = {
+  [NOBLE_MAINNET_CAIP2]: NOBLE_MAINNET_REST,
+  [NOBLE_TESTNET_CAIP2]: NOBLE_TESTNET_REST
+};
+var NOBLE_BECH32_PREFIX = "noble";
+var USDC_DENOM = "uusdc";
+var DEFAULT_GAS_LIMIT = 2e5;
+var DEFAULT_GAS_PRICE = "0.025uusdc";
+var DEFAULT_FEE_AMOUNT = "5000";
+var MSG_TYPE_SEND = "/cosmos.bank.v1beta1.MsgSend";
+var SCHEME_EXACT_DIRECT = "exact-direct";
+var MAX_TRANSACTION_AGE = 5 * 60 * 1e3;
+var COSMOS_CAIP2_NAMESPACE = "cosmos";
+
+// src/tokens.ts
+var TOKEN_REGISTRY = {
+  [NOBLE_MAINNET_CAIP2]: [
+    {
+      denom: USDC_DENOM,
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      priority: 1
+    }
+  ],
+  [NOBLE_TESTNET_CAIP2]: [
+    {
+      denom: USDC_DENOM,
+      symbol: "USDC",
+      name: "USD Coin (Testnet)",
+      decimals: 6,
+      priority: 1
+    }
+  ]
+};
+function getTokenConfig(network, symbol) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens) return void 0;
+  return tokens.find((t) => t.symbol.toUpperCase() === symbol.toUpperCase());
+}
+function getTokenByDenom(network, denom) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens) return void 0;
+  return tokens.find((t) => t.denom === denom);
+}
+function getDefaultToken(network) {
+  const tokens = TOKEN_REGISTRY[network];
+  if (!tokens || tokens.length === 0) return void 0;
+  return [...tokens].sort((a, b) => a.priority - b.priority)[0];
+}
+function getNetworkTokens(network) {
+  return TOKEN_REGISTRY[network] || [];
+}
+function isNetworkSupported(network) {
+  return network in TOKEN_REGISTRY;
+}
+
+// src/utils.ts
+function normalizeNetwork(network) {
+  if (network.startsWith(`${COSMOS_CAIP2_NAMESPACE}:`)) {
+    return network;
+  }
+  return `${COSMOS_CAIP2_NAMESPACE}:${network}`;
+}
+function extractNetworkId(network) {
+  if (network.includes(":")) {
+    return network.split(":")[1];
+  }
+  return network;
+}
+function isValidAddress(address) {
+  if (!address || address.length < 10) {
+    return false;
+  }
+  return address.startsWith(`${NOBLE_BECH32_PREFIX}1`);
+}
+function getRpcEndpoint(network) {
+  const normalizedNetwork = normalizeNetwork(network);
+  return NETWORK_RPC_ENDPOINTS[normalizedNetwork] || NETWORK_RPC_ENDPOINTS["cosmos:noble-1"];
+}
+function getRestEndpoint(network) {
+  const normalizedNetwork = normalizeNetwork(network);
+  return NETWORK_REST_ENDPOINTS[normalizedNetwork] || NETWORK_REST_ENDPOINTS["cosmos:noble-1"];
+}
+function toAtomicUnits(decimalAmount, decimals) {
+  const amount = typeof decimalAmount === "string" ? parseFloat(decimalAmount) : decimalAmount;
+  if (isNaN(amount)) {
+    throw new Error(`Invalid amount: ${decimalAmount}`);
+  }
+  const multiplier = 10 ** decimals;
+  return BigInt(Math.floor(amount * multiplier));
+}
+function formatAmount(amount, decimals) {
+  const divisor = BigInt(10 ** decimals);
+  const whole = amount / divisor;
+  const remainder = amount % divisor;
+  const decimal = remainder.toString().padStart(decimals, "0").slice(0, 2);
+  return `${whole}.${decimal}`;
+}
+function getSupportedNetworks() {
+  return Object.keys(NETWORK_RPC_ENDPOINTS);
+}
+
+// src/exact-direct/client/scheme.ts
+var ExactDirectCosmosClient = class {
+  /**
+   * Creates a new ExactDirectCosmosClient instance.
+   *
+   * @param signer - The Cosmos signer for client operations
+   * @param config - Optional configuration overrides
+   */
+  constructor(signer, config = {}) {
+    this.signer = signer;
+    this.config = config;
+    this.scheme = SCHEME_EXACT_DIRECT;
+  }
+  /**
+   * Creates a payment payload by executing the transfer.
+   *
+   * Unlike other schemes where the client creates a signed message for
+   * the facilitator to execute, the exact-direct scheme has the client
+   * execute the transfer directly. The transaction hash is then used
+   * as proof of payment.
+   *
+   * @param t402Version - The t402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @returns Promise resolving to a payment payload with transaction hash
+   */
+  async createPaymentPayload(t402Version, paymentRequirements) {
+    const network = normalizeNetwork(paymentRequirements.network);
+    if (!paymentRequirements.payTo) {
+      throw new Error("PayTo address is required");
+    }
+    if (!paymentRequirements.amount) {
+      throw new Error("Amount is required");
+    }
+    if (!isValidAddress(paymentRequirements.payTo)) {
+      throw new Error(`Invalid recipient address: ${paymentRequirements.payTo}`);
+    }
+    if (!isValidAddress(this.signer.address)) {
+      throw new Error(`Invalid sender address: ${this.signer.address}`);
+    }
+    const recipient = paymentRequirements.payTo;
+    const amount = paymentRequirements.amount;
+    const denom = paymentRequirements.extra?.denom || this.config.denom || USDC_DENOM;
+    const txHash = await this.signer.sendTokens(network, recipient, amount, denom);
+    const payload = {
+      txHash,
+      from: this.signer.address,
+      to: recipient,
+      amount,
+      denom
+    };
+    return {
+      t402Version,
+      payload
+    };
+  }
+};
+
+// src/exact-direct/server/scheme.ts
+var ExactDirectCosmosServer = class {
+  constructor(config = {}) {
+    this.scheme = SCHEME_EXACT_DIRECT;
+    this.moneyParsers = [];
+    this.config = config;
+  }
+  /**
+   * Register a custom money parser in the parser chain.
+   * Multiple parsers can be registered - they will be tried in registration order.
+   * Each parser receives a decimal amount (e.g., 1.50 for $1.50).
+   * If a parser returns null, the next parser in the chain will be tried.
+   * The default parser is always the final fallback.
+   *
+   * @param parser - Custom function to convert amount to AssetAmount (or null to skip)
+   * @returns The server instance for chaining
+   */
+  registerMoneyParser(parser) {
+    this.moneyParsers.push(parser);
+    return this;
+  }
+  /**
+   * Parses a price into an asset amount.
+   * If price is already an AssetAmount, returns it directly.
+   * If price is Money (string | number), parses to decimal and tries custom parsers.
+   * Falls back to default conversion if all custom parsers return null.
+   *
+   * @param price - The price to parse
+   * @param network - The network to use
+   * @returns Promise that resolves to the parsed asset amount
+   */
+  async parsePrice(price, network) {
+    const normalizedNetwork = normalizeNetwork(network);
+    if (typeof price === "object" && price !== null && "amount" in price) {
+      if (!price.asset) {
+        throw new Error(`Asset address must be specified for AssetAmount on network ${network}`);
+      }
+      return {
+        amount: price.amount,
+        asset: price.asset,
+        extra: price.extra || {}
+      };
+    }
+    const amount = this.parseMoneyToDecimal(price);
+    for (const parser of this.moneyParsers) {
+      const result = await parser(amount, normalizedNetwork);
+      if (result !== null) {
+        return result;
+      }
+    }
+    return this.defaultMoneyConversion(amount, normalizedNetwork);
+  }
+  /**
+   * Build payment requirements for this scheme/network combination.
+   *
+   * @param paymentRequirements - Base payment requirements with amount/asset already set
+   * @param supportedKind - The supported kind from facilitator's /supported endpoint
+   * @param extensionKeys - Extensions supported by the facilitator
+   * @returns Enhanced payment requirements ready to be sent to clients
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
+    void extensionKeys;
+    const extra = { ...paymentRequirements.extra };
+    const normalizedNetwork = normalizeNetwork(paymentRequirements.network);
+    const token = getDefaultToken(normalizedNetwork);
+    if (token) {
+      extra.bech32Prefix = NOBLE_BECH32_PREFIX;
+      extra.denom = token.denom;
+    }
+    if (supportedKind.extra?.assetSymbol) {
+      extra.assetSymbol = supportedKind.extra.assetSymbol;
+    }
+    if (supportedKind.extra?.assetDecimals) {
+      extra.assetDecimals = supportedKind.extra.assetDecimals;
+    }
+    if (supportedKind.extra?.assetDenom) {
+      extra.assetDenom = supportedKind.extra.assetDenom;
+    }
+    return {
+      ...paymentRequirements,
+      extra
+    };
+  }
+  /**
+   * Parse Money (string | number) to a decimal number.
+   * Handles formats like "$1.50", "1.50", 1.50, etc.
+   */
+  parseMoneyToDecimal(money) {
+    if (typeof money === "number") {
+      return money;
+    }
+    const cleanMoney = money.replace(/^\$/, "").trim();
+    const amount = parseFloat(cleanMoney);
+    if (isNaN(amount)) {
+      throw new Error(`Invalid money format: ${money}`);
+    }
+    return amount;
+  }
+  /**
+   * Default money conversion implementation.
+   * Converts decimal amount to the preferred token on the specified network.
+   */
+  defaultMoneyConversion(amount, network) {
+    const token = this.getDefaultAsset(network);
+    const tokenAmount = toAtomicUnits(amount, token.decimals);
+    return {
+      amount: tokenAmount.toString(),
+      asset: token.denom,
+      extra: {
+        symbol: token.symbol,
+        name: token.name,
+        decimals: token.decimals
+      }
+    };
+  }
+  /**
+   * Get the default asset info for a network.
+   * Priority: configured preferredToken > network default
+   */
+  getDefaultAsset(network) {
+    if (this.config.preferredToken) {
+      const preferred = getTokenConfig(network, this.config.preferredToken);
+      if (preferred) return preferred;
+    }
+    const defaultToken = getDefaultToken(network);
+    if (defaultToken) return defaultToken;
+    throw new Error(`No tokens configured for network ${network}`);
+  }
+  /**
+   * Get all supported networks
+   */
+  static getSupportedNetworks() {
+    return Object.keys(TOKEN_REGISTRY);
+  }
+  /**
+   * Check if a network is supported
+   */
+  static isNetworkSupported(network) {
+    return network in TOKEN_REGISTRY;
+  }
+};
+
+// src/exact-direct/facilitator/scheme.ts
+var ExactDirectCosmosFacilitator = class {
+  constructor(signer, config) {
+    this.signer = signer;
+    this.scheme = SCHEME_EXACT_DIRECT;
+    this.caipFamily = `${COSMOS_CAIP2_NAMESPACE}:*`;
+    this.usedTxs = /* @__PURE__ */ new Map();
+    this.config = {
+      maxTransactionAge: config?.maxTransactionAge ?? MAX_TRANSACTION_AGE,
+      usedTxCacheDuration: config?.usedTxCacheDuration ?? 24 * 60 * 60 * 1e3
+      // 24 hours
+    };
+    this.startCleanupInterval();
+  }
+  /**
+   * Get extra data for a supported kind
+   */
+  getExtra(network) {
+    const token = getDefaultToken(network);
+    if (!token) {
+      return void 0;
+    }
+    return {
+      assetSymbol: token.symbol,
+      assetDecimals: token.decimals,
+      assetDenom: token.denom
+    };
+  }
+  /**
+   * Get signer addresses for a network
+   */
+  getSigners(network) {
+    return this.signer.getAddresses(network);
+  }
+  /**
+   * Verify a payment payload
+   */
+  async verify(payload, requirements) {
+    const network = normalizeNetwork(requirements.network);
+    if (payload.accepted.scheme !== SCHEME_EXACT_DIRECT) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_scheme"
+      };
+    }
+    if (normalizeNetwork(payload.accepted.network) !== network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch"
+      };
+    }
+    const cosmosPayload = payload.payload;
+    if (!cosmosPayload.txHash) {
+      return {
+        isValid: false,
+        invalidReason: "missing_tx_hash"
+      };
+    }
+    if (!cosmosPayload.from || !isValidAddress(cosmosPayload.from)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_from_address"
+      };
+    }
+    if (this.isTxUsed(cosmosPayload.txHash)) {
+      return {
+        isValid: false,
+        invalidReason: "transaction_already_used",
+        payer: cosmosPayload.from
+      };
+    }
+    try {
+      const tx = await this.signer.queryTransaction(network, cosmosPayload.txHash);
+      if (tx.code !== 0) {
+        return {
+          isValid: false,
+          invalidReason: "transaction_failed",
+          payer: cosmosPayload.from
+        };
+      }
+      const msgSend = this.findMsgSend(tx.tx.body.messages);
+      if (!msgSend) {
+        return {
+          isValid: false,
+          invalidReason: "no_msg_send_found",
+          payer: cosmosPayload.from
+        };
+      }
+      if (msgSend.toAddress !== requirements.payTo) {
+        return {
+          isValid: false,
+          invalidReason: "wrong_recipient",
+          payer: cosmosPayload.from
+        };
+      }
+      if (msgSend.fromAddress !== cosmosPayload.from) {
+        return {
+          isValid: false,
+          invalidReason: "sender_mismatch",
+          payer: cosmosPayload.from
+        };
+      }
+      const expectedDenom = requirements.extra?.denom || requirements.asset;
+      const coin = this.getAmountByDenom(msgSend, expectedDenom);
+      if (!coin) {
+        return {
+          isValid: false,
+          invalidReason: "wrong_denomination",
+          payer: cosmosPayload.from
+        };
+      }
+      const txAmount = BigInt(coin.amount);
+      const requiredAmount = BigInt(requirements.amount);
+      if (txAmount < requiredAmount) {
+        return {
+          isValid: false,
+          invalidReason: "insufficient_amount",
+          payer: cosmosPayload.from
+        };
+      }
+      this.markTxUsed(cosmosPayload.txHash);
+      return {
+        isValid: true,
+        payer: cosmosPayload.from
+      };
+    } catch {
+      return {
+        isValid: false,
+        invalidReason: "transaction_not_found",
+        payer: cosmosPayload.from
+      };
+    }
+  }
+  /**
+   * Settle a payment - for exact-direct, the transfer is already complete
+   */
+  async settle(payload, requirements) {
+    const verifyResult = await this.verify(payload, requirements);
+    if (!verifyResult.isValid) {
+      return {
+        success: false,
+        errorReason: verifyResult.invalidReason || "verification_failed",
+        payer: verifyResult.payer,
+        transaction: "",
+        network: normalizeNetwork(requirements.network)
+      };
+    }
+    const cosmosPayload = payload.payload;
+    return {
+      success: true,
+      transaction: cosmosPayload.txHash,
+      network: normalizeNetwork(requirements.network),
+      payer: cosmosPayload.from
+    };
+  }
+  /**
+   * Find a MsgSend in transaction messages
+   */
+  findMsgSend(messages) {
+    for (const msg of messages) {
+      if (msg["@type"] === MSG_TYPE_SEND || !msg["@type"] && msg.fromAddress && msg.toAddress) {
+        return msg;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get a specific coin amount from a MsgSend by denomination
+   */
+  getAmountByDenom(msg, denom) {
+    for (const coin of msg.amount) {
+      if (coin.denom === denom) {
+        return coin;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if a transaction has been used
+   */
+  isTxUsed(txHash) {
+    return this.usedTxs.has(txHash);
+  }
+  /**
+   * Mark a transaction as used
+   */
+  markTxUsed(txHash) {
+    this.usedTxs.set(txHash, Date.now());
+  }
+  /**
+   * Start the cleanup interval for used transactions
+   */
+  startCleanupInterval() {
+    setInterval(
+      () => {
+        const cutoff = Date.now() - this.config.usedTxCacheDuration;
+        for (const [txHash, usedAt] of this.usedTxs.entries()) {
+          if (usedAt < cutoff) {
+            this.usedTxs.delete(txHash);
+          }
+        }
+      },
+      60 * 60 * 1e3
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COSMOS_CAIP2_NAMESPACE,
+  COSMOS_NETWORKS,
+  DEFAULT_FEE_AMOUNT,
+  DEFAULT_GAS_LIMIT,
+  DEFAULT_GAS_PRICE,
+  ExactDirectCosmosClient,
+  ExactDirectCosmosFacilitator,
+  ExactDirectCosmosServer,
+  MAX_TRANSACTION_AGE,
+  MSG_TYPE_SEND,
+  NETWORK_REST_ENDPOINTS,
+  NETWORK_RPC_ENDPOINTS,
+  NOBLE_BECH32_PREFIX,
+  NOBLE_MAINNET_CAIP2,
+  NOBLE_MAINNET_REST,
+  NOBLE_MAINNET_RPC,
+  NOBLE_TESTNET_CAIP2,
+  NOBLE_TESTNET_REST,
+  NOBLE_TESTNET_RPC,
+  SCHEME_EXACT_DIRECT,
+  TOKEN_REGISTRY,
+  USDC_DENOM,
+  extractNetworkId,
+  formatAmount,
+  getDefaultToken,
+  getNetworkTokens,
+  getRestEndpoint,
+  getRpcEndpoint,
+  getSupportedNetworks,
+  getTokenByDenom,
+  getTokenConfig,
+  isNetworkSupported,
+  isValidAddress,
+  normalizeNetwork,
+  toAtomicUnits
+});
+//# sourceMappingURL=index.js.map