@zkp2p/sdk 0.0.8 → 0.0.10

package/dist/index.cjs

@@ -21,10 +21,10 @@ var basePaymentMethodsRaw = require('@zkp2p/contracts-v2/paymentMethods/base.jso
 var baseSepoliaPaymentMethodsRaw = require('@zkp2p/contracts-v2/paymentMethods/baseSepolia.json');
 var baseStagingPaymentMethodsRaw = require('@zkp2p/contracts-v2/paymentMethods/baseStaging.json');
 var viem = require('viem');
-var ethers = require('ethers');
 var baseSepoliaPaymentMethods2 = require('@zkp2p/contracts-v2/paymentMethods/baseSepolia');
 var baseStagingPaymentMethods2 = require('@zkp2p/contracts-v2/paymentMethods/baseStaging');
 var chains = require('viem/chains');
+var ethers = require('ethers');
 var erc8021 = require('ox/erc8021');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -52,38 +52,15 @@ var baseStagingPaymentMethodsRaw__default = /*#__PURE__*/_interopDefault(baseSta
 var baseSepoliaPaymentMethods2__default = /*#__PURE__*/_interopDefault(baseSepoliaPaymentMethods2);
 var baseStagingPaymentMethods2__default = /*#__PURE__*/_interopDefault(baseStagingPaymentMethods2);
 
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  __defProp(target, "default", { value: mod, enumerable: true }) ,
-  mod
-));
 function unwrapAddresses(mod) {
   if (!mod) return {};
   const m = mod;
@@ -298,7 +275,8 @@ function ensureBytes32(value, { hashIfAscii = false } = {}) {
     if (bytes.length !== 32) throw new Error("Expected 32-byte hex value");
     return value;
   }
-  if (!hashIfAscii) throw new Error("Expected 32-byte hex; received ascii string. Pass hashIfAscii=true to hash.");
+  if (!hashIfAscii)
+    throw new Error("Expected 32-byte hex; received ascii string. Pass hashIfAscii=true to hash.");
   const hashed = viem.keccak256(viem.toBytes(value));
   return hashed;
 }
@@ -313,2234 +291,13 @@ var init_bytes32 = __esm({
   "src/utils/bytes32.ts"() {
   }
 });
-
-// ../../node_modules/.pnpm/canonicalize@2.1.0/node_modules/canonicalize/lib/canonicalize.js
-var require_canonicalize = __commonJS({
-  "../../node_modules/.pnpm/canonicalize@2.1.0/node_modules/canonicalize/lib/canonicalize.js"(exports$1, module) {
-    module.exports = function serialize(object) {
-      if (typeof object === "number" && isNaN(object)) {
-        throw new Error("NaN is not allowed");
-      }
-      if (typeof object === "number" && !isFinite(object)) {
-        throw new Error("Infinity is not allowed");
-      }
-      if (object === null || typeof object !== "object") {
-        return JSON.stringify(object);
-      }
-      if (object.toJSON instanceof Function) {
-        return serialize(object.toJSON());
-      }
-      if (Array.isArray(object)) {
-        const values2 = object.reduce((t, cv, ci) => {
-          const comma = ci === 0 ? "" : ",";
-          const value = cv === void 0 || typeof cv === "symbol" ? null : cv;
-          return `${t}${comma}${serialize(value)}`;
-        }, "");
-        return `[${values2}]`;
-      }
-      const values = Object.keys(object).sort().reduce((t, cv) => {
-        if (object[cv] === void 0 || typeof object[cv] === "symbol") {
-          return t;
-        }
-        const comma = t.length === 0 ? "" : ",";
-        return `${t}${comma}${serialize(cv)}:${serialize(object[cv])}`;
-      }, "");
-      return `{${values}}`;
-    };
-  }
-});
-var usdcUnits, currencyKeccak256, Currency, currencyInfo, PaymentPlatform, venmoSendConfig, venmoVerifyConfig, venmoDepositConfig, venmoConfig, cashappSendConfig, cashappVerifyConfig, cashappDepositConfig, cashappConfig, chimeSendConfig, readChimeMetadataValue, formatChimeAmount, parseChimeDate, parseChimeMetadataFields, chimeVerifyConfig, chimeDepositConfig, chimeConfig, getMinorDigits, formatMajorAmountFromMinor, revolutSendConfig, revolutVerifyConfig, revolutDepositConfig, revolutConfig, getMinorDigits2, formatMajorAmountFromMinor2, wiseSendConfig, wiseVerifyConfig, wiseDepositConfig, wiseConfig, mercadoPagoSendConfig, mercadoPagoVerifyConfig, mercadoPagoDepositConfig, mercadoPagoConfig, encodeZelleRecipientId, zelleBankOfAmericaSendConfig, zelleBankOfAmericaVerifyConfig, zelleChaseSendConfig, zelleChaseVerifyConfig, zelleCitiSendConfig, zelleCitiVerifyConfig, zelleDepositConfig, zelleConfig, paypalSendConfig, paypalVerifyConfig, paypalDepositConfig, paypalConfig, monzoSendConfig, monzoVerifyConfig, monzoDepositConfig, monzoConfig, formatAmountFromCents, n26SendConfig, n26VerifyConfig, n26DepositConfig, n26Config, decodeUnicodeEscapes, parseAlipayAmount, parseAlipayDate, alipaySendConfig, alipayVerifyConfig, alipayDepositConfig, alipayConfig, METHOD_NAME_TO_HASH;
-var init_utils = __esm({
-  "../core/dist/utils/index.js"() {
-    __toESM(require_canonicalize());
-    usdcUnits = (amount) => {
-      return viem.parseUnits(amount.toString(), 6);
-    };
+var currencyKeccak256;
+var init_currencyKeccak256 = __esm({
+  "src/utils/currencyKeccak256.ts"() {
     currencyKeccak256 = (inputString) => {
       const bytes = new TextEncoder().encode(inputString);
       return viem.keccak256(bytes);
     };
-    Currency = {
-      AED: "AED",
-      ARS: "ARS",
-      AUD: "AUD",
-      CAD: "CAD",
-      CHF: "CHF",
-      CNY: "CNY",
-      CZK: "CZK",
-      DKK: "DKK",
-      EUR: "EUR",
-      GBP: "GBP",
-      HKD: "HKD",
-      HUF: "HUF",
-      IDR: "IDR",
-      ILS: "ILS",
-      INR: "INR",
-      JPY: "JPY",
-      KES: "KES",
-      NOK: "NOK",
-      MXN: "MXN",
-      MYR: "MYR",
-      NZD: "NZD",
-      PHP: "PHP",
-      PLN: "PLN",
-      RON: "RON",
-      SAR: "SAR",
-      SEK: "SEK",
-      SGD: "SGD",
-      THB: "THB",
-      TRY: "TRY",
-      UGX: "UGX",
-      USD: "USD",
-      VND: "VND",
-      ZAR: "ZAR"
-    };
-    currencyInfo = {
-      [Currency.AED]: {
-        currency: Currency.AED,
-        currencyCode: "AED",
-        currencyName: "United Arab Emirates Dirham",
-        currencyCodeHash: currencyKeccak256("AED"),
-        currencySymbol: "\u062F.\u0625",
-        countryCode: "ae"
-      },
-      [Currency.ARS]: {
-        currency: Currency.ARS,
-        currencyCode: "ARS",
-        currencyName: "Argentine Peso",
-        currencyCodeHash: currencyKeccak256("ARS"),
-        currencySymbol: "$",
-        countryCode: "ar"
-      },
-      [Currency.AUD]: {
-        currency: Currency.AUD,
-        currencyCode: "AUD",
-        currencyName: "Australian Dollar",
-        currencyCodeHash: currencyKeccak256("AUD"),
-        currencySymbol: "A$",
-        countryCode: "au"
-      },
-      [Currency.CAD]: {
-        currency: Currency.CAD,
-        currencyCode: "CAD",
-        currencyName: "Canadian Dollar",
-        currencyCodeHash: currencyKeccak256("CAD"),
-        currencySymbol: "C$",
-        countryCode: "ca"
-      },
-      [Currency.CHF]: {
-        currency: Currency.CHF,
-        currencyCode: "CHF",
-        currencyName: "Swiss Franc",
-        currencyCodeHash: currencyKeccak256("CHF"),
-        currencySymbol: "Fr",
-        countryCode: "ch"
-      },
-      [Currency.CNY]: {
-        currency: Currency.CNY,
-        currencyCode: "CNY",
-        currencyName: "Chinese Yuan",
-        currencyCodeHash: currencyKeccak256("CNY"),
-        currencySymbol: "\xA5",
-        countryCode: "cn"
-      },
-      [Currency.CZK]: {
-        currency: Currency.CZK,
-        currencyCode: "CZK",
-        currencyName: "Czech Koruna",
-        currencyCodeHash: currencyKeccak256("CZK"),
-        currencySymbol: "K\u010D",
-        countryCode: "cz"
-      },
-      [Currency.DKK]: {
-        currency: Currency.DKK,
-        currencyCode: "DKK",
-        currencyName: "Danish Krone",
-        currencyCodeHash: currencyKeccak256("DKK"),
-        currencySymbol: "kr",
-        countryCode: "dk"
-      },
-      [Currency.EUR]: {
-        currency: Currency.EUR,
-        currencyCode: "EUR",
-        currencyName: "Euro",
-        currencyCodeHash: currencyKeccak256("EUR"),
-        currencySymbol: "\u20AC",
-        countryCode: "eu"
-      },
-      [Currency.GBP]: {
-        currency: Currency.GBP,
-        currencyCode: "GBP",
-        currencyName: "British Pound",
-        currencyCodeHash: currencyKeccak256("GBP"),
-        currencySymbol: "\xA3",
-        countryCode: "gb"
-      },
-      [Currency.HKD]: {
-        currency: Currency.HKD,
-        currencyCode: "HKD",
-        currencyName: "Hong Kong Dollar",
-        currencyCodeHash: currencyKeccak256("HKD"),
-        currencySymbol: "HK$",
-        countryCode: "hk"
-      },
-      [Currency.HUF]: {
-        currency: Currency.HUF,
-        currencyCode: "HUF",
-        currencyName: "Hungarian Forint",
-        currencyCodeHash: currencyKeccak256("HUF"),
-        currencySymbol: "Ft",
-        countryCode: "hu"
-      },
-      [Currency.IDR]: {
-        currency: Currency.IDR,
-        currencyCode: "IDR",
-        currencyName: "Indonesian Rupiah",
-        currencyCodeHash: currencyKeccak256("IDR"),
-        currencySymbol: "Rp",
-        countryCode: "id"
-      },
-      [Currency.INR]: {
-        currency: Currency.INR,
-        currencyCode: "INR",
-        currencyName: "Indian Rupee",
-        currencyCodeHash: currencyKeccak256("INR"),
-        currencySymbol: "\u20B9",
-        countryCode: "in"
-      },
-      [Currency.ILS]: {
-        currency: Currency.ILS,
-        currencyCode: "ILS",
-        currencyName: "Israeli New Shekel",
-        currencyCodeHash: currencyKeccak256("ILS"),
-        currencySymbol: "\u20AA",
-        countryCode: "il"
-      },
-      [Currency.JPY]: {
-        currency: Currency.JPY,
-        currencyCode: "JPY",
-        currencyName: "Japanese Yen",
-        currencyCodeHash: currencyKeccak256("JPY"),
-        currencySymbol: "\xA5",
-        countryCode: "jp"
-      },
-      [Currency.KES]: {
-        currency: Currency.KES,
-        currencyCode: "KES",
-        currencyName: "Kenyan Shilling",
-        currencyCodeHash: currencyKeccak256("KES"),
-        currencySymbol: "KSh",
-        countryCode: "ke"
-      },
-      [Currency.MXN]: {
-        currency: Currency.MXN,
-        currencyCode: "MXN",
-        currencyName: "Mexican Peso",
-        currencyCodeHash: currencyKeccak256("MXN"),
-        currencySymbol: "$",
-        countryCode: "mx"
-      },
-      [Currency.MYR]: {
-        currency: Currency.MYR,
-        currencyCode: "MYR",
-        currencyName: "Malaysian Ringgit",
-        currencyCodeHash: currencyKeccak256("MYR"),
-        currencySymbol: "RM",
-        countryCode: "my"
-      },
-      [Currency.NOK]: {
-        currency: Currency.NOK,
-        currencyCode: "NOK",
-        currencyName: "Norwegian Krone",
-        currencyCodeHash: currencyKeccak256("NOK"),
-        currencySymbol: "kr",
-        countryCode: "no"
-      },
-      [Currency.NZD]: {
-        currency: Currency.NZD,
-        currencyCode: "NZD",
-        currencyName: "New Zealand Dollar",
-        currencyCodeHash: currencyKeccak256("NZD"),
-        currencySymbol: "NZ$",
-        countryCode: "nz"
-      },
-      [Currency.PHP]: {
-        currency: Currency.PHP,
-        currencyCode: "PHP",
-        currencyName: "Philippine Peso",
-        currencyCodeHash: currencyKeccak256("PHP"),
-        currencySymbol: "\u20B1",
-        countryCode: "ph"
-      },
-      [Currency.PLN]: {
-        currency: Currency.PLN,
-        currencyCode: "PLN",
-        currencyName: "Polish Z\u0142oty",
-        currencyCodeHash: currencyKeccak256("PLN"),
-        currencySymbol: "z\u0142",
-        countryCode: "pl"
-      },
-      [Currency.RON]: {
-        currency: Currency.RON,
-        currencyCode: "RON",
-        currencyName: "Romanian Leu",
-        currencyCodeHash: currencyKeccak256("RON"),
-        currencySymbol: "lei",
-        countryCode: "ro"
-      },
-      [Currency.SAR]: {
-        currency: Currency.SAR,
-        currencyCode: "SAR",
-        currencyName: "Saudi Riyal",
-        currencyCodeHash: currencyKeccak256("SAR"),
-        currencySymbol: "\uFDFC",
-        countryCode: "sa"
-      },
-      [Currency.SEK]: {
-        currency: Currency.SEK,
-        currencyCode: "SEK",
-        currencyName: "Swedish Krona",
-        currencyCodeHash: currencyKeccak256("SEK"),
-        currencySymbol: "kr",
-        countryCode: "se"
-      },
-      [Currency.SGD]: {
-        currency: Currency.SGD,
-        currencyCode: "SGD",
-        currencyName: "Singapore Dollar",
-        currencyCodeHash: currencyKeccak256("SGD"),
-        currencySymbol: "S$",
-        countryCode: "sg"
-      },
-      [Currency.THB]: {
-        currency: Currency.THB,
-        currencyCode: "THB",
-        currencyName: "Thai Baht",
-        currencyCodeHash: currencyKeccak256("THB"),
-        currencySymbol: "\u0E3F",
-        countryCode: "th"
-      },
-      [Currency.TRY]: {
-        currency: Currency.TRY,
-        currencyCode: "TRY",
-        currencyName: "Turkish Lira",
-        currencyCodeHash: currencyKeccak256("TRY"),
-        currencySymbol: "\u20BA",
-        countryCode: "tr"
-      },
-      [Currency.UGX]: {
-        currency: Currency.UGX,
-        currencyCode: "UGX",
-        currencyName: "Ugandan Shilling",
-        currencyCodeHash: currencyKeccak256("UGX"),
-        currencySymbol: "USh",
-        countryCode: "ug"
-      },
-      [Currency.USD]: {
-        currency: Currency.USD,
-        currencyCode: "USD",
-        currencyName: "United States Dollar",
-        currencyCodeHash: currencyKeccak256("USD"),
-        currencySymbol: "$",
-        countryCode: "us"
-      },
-      [Currency.VND]: {
-        currency: Currency.VND,
-        currencyCode: "VND",
-        currencyName: "Vietnamese Dong",
-        currencyCodeHash: currencyKeccak256("VND"),
-        currencySymbol: "\u20AB",
-        countryCode: "vn"
-      },
-      [Currency.ZAR]: {
-        currency: Currency.ZAR,
-        currencyCode: "ZAR",
-        currencyName: "South African Rand",
-        currencyCodeHash: currencyKeccak256("ZAR"),
-        currencySymbol: "R",
-        countryCode: "za"
-      }
-    };
-    PaymentPlatform = {
-      VENMO: "venmo",
-      CASHAPP: "cashapp",
-      CHIME: "chime",
-      REVOLUT: "revolut",
-      WISE: "wise",
-      MERCADO_PAGO: "mercadopago",
-      ZELLE: "zelle",
-      PAYPAL: "paypal",
-      MONZO: "monzo",
-      N26: "n26",
-      ALIPAY: "alipay"
-    };
-    [...Object.values(PaymentPlatform)];
-    venmoSendConfig = {
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://account.venmo.com/pay?recipients=${recipientId}&note=Thx&amount=${amountFiatToSend?.replace(",", "")}`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `venmo://paycharge?txn=pay&recipients=${recipientId}&note=Thx&amount=${amountFiatToSend?.replace(",", "")}`,
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Please do NOT toggle the "Turn on for purchases" option. Ensure you pay friends & family when making the payment on Venmo.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment. Double-check the username before confirming.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] },
-        { text: "Pay friends & family", emphasize: ["friends & family"] },
-        { text: "Double-check the username before confirming", emphasize: ["Double-check"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not use a business account", emphasize: ["Do not", "business"] },
-        { text: 'Do not toggle "Turn on for purchases"', emphasize: ["Do not", "Turn on for purchases"] },
-        { text: "Do not include zkp2p, crypto, or related terms in the memo", emphasize: ["zkp2p", "crypto"] }
-      ]
-    };
-    venmoVerifyConfig = {
-      authLink: "https://account.venmo.com/?feed=mine",
-      actionType: "transfer_venmo",
-      actionPlatform: "venmo",
-      numPaymentsFetched: 10,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = /* @__PURE__ */ new Date(params.date + "Z");
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        const amount = Number(params.amount.replace("-", "")).toString();
-        return {
-          amount,
-          date: formattedDate,
-          currency: "USD",
-          paymentPlatform: PaymentPlatform.VENMO,
-          paymentId: params.paymentId,
-          recipient: params.receiverId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountStr = String(metadata.amount ?? "").replace(/[^0-9.]/g, "");
-          const dateStr = `${metadata.date ?? ""}Z`;
-          const recipientIdStr = metadata.recipient || "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: recipientIdStr,
-            parsedRecipientId: recipientIdStr !== "",
-            currency: Currency.USD,
-            parsedCurrency: true
-          };
-        } catch (error) {
-          console.error("[Venmo] Failed to parse payment metadata:", {
-            error: error instanceof Error ? error.message : error,
-            metadata
-          });
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        const venmoStringSplit = String(metadata.amount ?? "").split(" ");
-        return venmoStringSplit[0] === "-" ? `Sent ${venmoStringSplit[1]} to ${metadata.recipient}` : ``;
-      }
-    };
-    venmoDepositConfig = {
-      depositRequiresApproval: false,
-      payeeDetailInputPlaceholder: "Enter your Venmo username",
-      payeeDetailInputHelperText: "This is your Venmo username",
-      payeeDetailValidationFailureMessage: "Make sure there are no typos in your username. Do not include the @. Username is case sensitive.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          venmoUsername: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.venmoUsername;
-      }
-    };
-    venmoConfig = {
-      platformId: PaymentPlatform.VENMO,
-      platformName: "Venmo",
-      platformCurrencies: [Currency.USD],
-      platformLogo: void 0,
-      // venmoLogo - Legal counsel advised not to use logo
-      platformColor: "#3D95CE",
-      // Venmo's brand blue color
-      minFiatAmount: "0.1",
-      // 0.1 USD
-      maxUsdcPerIntent: "5000",
-      // Client-side pre-validation to avoid unnecessary API calls
-      localeTimeString: "en-US",
-      depositConfig: venmoDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: venmoSendConfig,
-          verifyConfig: venmoVerifyConfig
-        }
-      ]
-    };
-    cashappSendConfig = {
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: false,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => recipientId.startsWith("$") ? `https://cash.app/qr/${recipientId}?size=288&margin=0` : `https://cash.app/qr/$${recipientId}?size=288&margin=0`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => recipientId.startsWith("$") ? `https://cash.app/qr/${recipientId}?size=288&margin=0` : `https://cash.app/qr/$${recipientId}?size=288&margin=0`,
-      supportsSendingPaymentOnWeb: false,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Please do not put zkp2p, crypto or any related terms in the payment notes or memo field.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] },
-        { text: "Use the Cash App QR or Cashtag to pay" },
-        { text: "Double-check the recipient before confirming", emphasize: ["Double-check"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not include zkp2p, crypto, or related terms in the memo", emphasize: ["zkp2p", "crypto"] }
-      ]
-    };
-    cashappVerifyConfig = {
-      authLink: "https://cash.app/account/activity",
-      actionType: "transfer_cashapp",
-      actionPlatform: "cashapp",
-      numPaymentsFetched: 15,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(Number(params.date));
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        return {
-          amount: params.amount,
-          date: formattedDate,
-          currency: params.currency_code,
-          paymentPlatform: PaymentPlatform.CASHAPP,
-          paymentId: params.paymentId,
-          recipient: params.receiverId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountUnits = Number(metadata.amount) / 100;
-          const amountStr = parseFloat(amountUnits.toFixed(2)).toString();
-          const currency = metadata.currency ?? "";
-          const dateString = new Date(metadata.date ?? "").toISOString();
-          const recipientId = metadata.recipient ?? "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateString,
-            parsedDate: dateString !== "",
-            recipientId,
-            parsedRecipientId: recipientId !== "",
-            currency,
-            parsedCurrency: currency !== ""
-          };
-        } catch (error) {
-          console.error("Error parsing Cash App metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        return `Transfer of $${Number(metadata.amount) / 100} to ${metadata.recipient}`;
-      }
-    };
-    cashappDepositConfig = {
-      depositRequiresApproval: false,
-      payeeDetailInputPlaceholder: "Enter your Cashtag",
-      payeeDetailInputHelperText: "This is your Cashtag. Please ensure you have set your Cashtag as discoverable by others. Do not include the $ symbol.",
-      payeeDetailValidationFailureMessage: "Make sure you have set your Cashtag as discoverable by others. Do not include the $ symbol.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          cashtag: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        const tag = data.cashtag;
-        return tag.startsWith("$") ? tag : `$${tag}`;
-      }
-    };
-    cashappConfig = {
-      platformId: PaymentPlatform.CASHAPP,
-      platformLogo: "",
-      platformName: "Cash App",
-      platformColor: "#00D632",
-      // Cash App's brand green color
-      platformCurrencies: [Currency.USD],
-      minFiatAmount: "0.1",
-      // 0.1 USD
-      localeTimeString: "en-US",
-      depositConfig: cashappDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: cashappSendConfig,
-          verifyConfig: cashappVerifyConfig
-        }
-      ]
-    };
-    chimeSendConfig = {
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://app.chime.com/login`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `https://app.chime.com/link/qr?u=${recipientId}`,
-      supportsSendingPaymentOnWeb: false,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Please do not put zkp2p, crypto or any related terms in the payment notes or memo field.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] },
-        { text: "Use the Chime QR or ChimeSign to pay" },
-        { text: "Double-check the recipient before confirming", emphasize: ["Double-check"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not include zkp2p, crypto, or related terms in the memo", emphasize: ["zkp2p", "crypto"] }
-      ]
-    };
-    readChimeMetadataValue = (value) => {
-      if (Array.isArray(value)) {
-        const [first] = value;
-        return first === void 0 || first === null ? "" : String(first);
-      }
-      return value === void 0 || value === null ? "" : String(value);
-    };
-    formatChimeAmount = (value) => {
-      const amountValue = Number(value);
-      if (!Number.isFinite(amountValue)) {
-        return "";
-      }
-      return parseFloat(amountValue.toFixed(2)).toString();
-    };
-    parseChimeDate = (value) => {
-      if (!value) {
-        return "";
-      }
-      const parsedDate = new Date(value);
-      if (Number.isNaN(parsedDate.getTime())) {
-        return "";
-      }
-      return parsedDate.toISOString();
-    };
-    parseChimeMetadataFields = (metadata) => {
-      if (Array.isArray(metadata)) {
-        const [
-          headerDate,
-          amountRaw,
-          isoDate,
-          recipientRaw,
-          _paymentIdRaw,
-          statusRaw
-        ] = metadata;
-        return {
-          amountStr: formatChimeAmount(readChimeMetadataValue(amountRaw)),
-          currency: Currency.USD,
-          dateString: parseChimeDate(readChimeMetadataValue(isoDate) || readChimeMetadataValue(headerDate)),
-          recipientId: readChimeMetadataValue(recipientRaw),
-          status: readChimeMetadataValue(statusRaw)
-        };
-      }
-      const typedMetadata = metadata;
-      return {
-        amountStr: formatChimeAmount(typedMetadata.amount),
-        currency: typedMetadata.currency ?? Currency.USD,
-        dateString: parseChimeDate(typedMetadata.date ?? ""),
-        recipientId: typedMetadata.recipient ?? "",
-        status: ""
-      };
-    };
-    chimeVerifyConfig = {
-      authLink: "https://app.chime.com/login",
-      actionType: "transfer_chime",
-      actionPlatform: "chime",
-      numPaymentsFetched: 1,
-      minExtensionVersion: "0.3.0",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(Number(params.date));
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        return {
-          amount: params.amount,
-          date: formattedDate,
-          currency: params.currency_code,
-          paymentPlatform: PaymentPlatform.CHIME,
-          paymentId: params.paymentId,
-          recipient: params.receiverId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const {
-            amountStr,
-            currency,
-            dateString,
-            recipientId
-          } = parseChimeMetadataFields(metadata);
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateString,
-            parsedDate: dateString !== "",
-            recipientId,
-            parsedRecipientId: recipientId !== "",
-            currency,
-            parsedCurrency: currency !== ""
-          };
-        } catch (error) {
-          console.error("Error parsing Chime metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        const { amountStr, recipientId, status } = parseChimeMetadataFields(metadata);
-        if (!amountStr || !recipientId) {
-          return "";
-        }
-        if (status && status !== "SUCCEEDED") {
-          return "";
-        }
-        return `Transfer of $${amountStr} to ${recipientId}`;
-      }
-    };
-    chimeDepositConfig = {
-      depositRequiresApproval: false,
-      payeeDetailInputPlaceholder: "Enter your $ChimeSign",
-      payeeDetailInputHelperText: "This is your ChimeSign. Please ensure you have set your ChimeSign as discoverable by others. Include the $ symbol.",
-      payeeDetailValidationFailureMessage: "Make sure you have set your ChimeSign as discoverable by others and include the $ symbol.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        const normalizedPayeeDetails = payeeDetails.trim().toLowerCase();
-        return {
-          chimesign: normalizedPayeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        const normalizedSign = data.chimesign?.trim().toLowerCase() ?? "";
-        return normalizedSign;
-      }
-    };
-    chimeConfig = {
-      platformId: PaymentPlatform.CHIME,
-      platformLogo: "",
-      platformName: "Chime",
-      platformColor: "#1EC677",
-      // Chime brand green
-      platformCurrencies: [Currency.USD],
-      minFiatAmount: "0.1",
-      // 0.1 USD
-      localeTimeString: "en-US",
-      depositConfig: chimeDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: chimeSendConfig,
-          verifyConfig: chimeVerifyConfig
-        }
-      ]
-    };
-    getMinorDigits = (currency) => {
-      const code = (currency || "").toString().toUpperCase();
-      return code === "JPY" ? 0 : 2;
-    };
-    formatMajorAmountFromMinor = (minorAmount, currency) => {
-      const digits = getMinorDigits(currency);
-      const major = minorAmount / Math.pow(10, digits);
-      if (digits === 0) {
-        return Math.round(major).toString();
-      }
-      return parseFloat(major.toFixed(digits)).toString();
-    };
-    revolutSendConfig = {
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://revolut.me/${recipientId}`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `https://revolut.me/${recipientId}`,
-      supportsSendingPaymentOnWeb: false,
-      showTroubleScanningQRCodeLink: false,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Avoid cross-currency conversion. If you do send the wrong currency, a 5% penalty will be automatically applied.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Use your existing Revolut account. Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment. Ensure the seller receives exactly ${currencyInfo[sendCurrency].currencyCode}.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: "Use your existing Revolut account", emphasize: ["existing"] },
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] },
-        { text: `Ensure the seller receives exactly ${currencyInfo[sendCurrency].currencyCode}`, emphasize: ["exactly", currencyInfo[sendCurrency].currencyCode] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Avoid cross-currency conversion", emphasize: ["cross-currency"] },
-        { text: "If you do send the wrong currency, a 5% penalty will be automatically applied.", emphasize: ["5% penalty"] },
-        { text: "Do not pay from a Revolut Business account", emphasize: ["Revolut Business"] }
-      ]
-    };
-    revolutVerifyConfig = {
-      authLink: "https://app.revolut.com/home",
-      actionType: "transfer_revolut",
-      actionPlatform: "revolut",
-      numPaymentsFetched: 20,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(Number(params.completedDate));
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        const amount = formatMajorAmountFromMinor(
-          Number(params.amount.replace("-", "")),
-          params.currency
-        );
-        return {
-          amount,
-          date: formattedDate,
-          currency: params.currency,
-          paymentPlatform: PaymentPlatform.REVOLUT,
-          paymentId: params.id,
-          recipient: params.username,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountStr = formatMajorAmountFromMinor(
-            Number(metadata.amount) * -1,
-            metadata.currency
-          );
-          const dateStr = metadata.date ? new Date(metadata.date).toISOString() : "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: metadata.recipient ?? "",
-            parsedRecipientId: metadata.recipient ? true : false,
-            currency: metadata.currency ?? "",
-            parsedCurrency: metadata.currency ? true : false
-          };
-        } catch (error) {
-          console.error("Error parsing Revolut metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        if (Number(metadata.amount) < 0) {
-          const currencySymbol = currencyInfo[metadata.currency ?? ""]?.currencySymbol ?? "";
-          const revolutFormattedAmount = formatMajorAmountFromMinor(
-            Number(metadata.amount) * -1,
-            metadata.currency
-          );
-          return `Sent ${currencySymbol}${revolutFormattedAmount} to ${metadata.recipient} `;
-        } else {
-          return ``;
-        }
-      }
-    };
-    revolutDepositConfig = {
-      depositRequiresApproval: false,
-      // Align with product guidance: clarify that '@' should not be included.
-      payeeDetailInputPlaceholder: "Enter your Revtag (without @)",
-      payeeDetailInputHelperText: "This is your Revtag. Do not include the @. Make sure you have set your Revtag to be publicly discoverable.",
-      payeeDetailValidationFailureMessage: "Do not include the @. Make sure your Revtag is publicly discoverable and there are no typos.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          revolutUsername: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.revolutUsername;
-      }
-    };
-    revolutConfig = {
-      platformId: PaymentPlatform.REVOLUT,
-      platformName: "Revolut",
-      platformLogo: "",
-      platformColor: "#000000",
-      // Revolut's brand blue color
-      platformCurrencies: [
-        Currency.USD,
-        Currency.EUR,
-        Currency.GBP,
-        Currency.SGD,
-        Currency.NZD,
-        Currency.AUD,
-        Currency.CAD,
-        Currency.HKD,
-        Currency.MXN,
-        Currency.SAR,
-        Currency.AED,
-        Currency.THB,
-        Currency.TRY,
-        Currency.PLN,
-        Currency.CHF,
-        Currency.ZAR,
-        Currency.JPY,
-        Currency.CZK,
-        Currency.CNY,
-        Currency.DKK,
-        Currency.HUF,
-        Currency.NOK,
-        Currency.RON,
-        Currency.SEK
-      ],
-      minFiatAmount: "0.1",
-      // 0.1 USD/EUR/GBP
-      localeTimeString: "en-US",
-      depositConfig: revolutDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: revolutSendConfig,
-          verifyConfig: revolutVerifyConfig
-        }
-      ]
-    };
-    getMinorDigits2 = (currency) => {
-      const code = (currency || "").toString().toUpperCase();
-      return code === "JPY" ? 0 : 2;
-    };
-    formatMajorAmountFromMinor2 = (minorAmount, currency) => {
-      const digits = getMinorDigits2(currency);
-      const major = minorAmount / Math.pow(10, digits);
-      if (digits === 0) {
-        return Math.round(major).toString();
-      }
-      return parseFloat(major.toFixed(digits)).toString();
-    };
-    wiseSendConfig = {
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://wise.com/pay/me/${recipientId}`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `https://wise.com/pay/me/${recipientId}`,
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Avoid cross-currency conversion, if you do send cross currency you will lose 5%.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Ensure the seller receives exactly ${currencyInfo[sendCurrency].currencyCode} in a single payment. Please do not put zkp2p, crypto or any related terms in the payment notes or memo field.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: `Ensure the seller receives exactly ${currencyInfo[sendCurrency].currencyCode}`, emphasize: ["exactly", currencyInfo[sendCurrency].currencyCode] },
-        { text: "Send in a single payment", emphasize: ["single"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Avoid cross-currency conversion, if you do send cross currency you will lose 5%.", emphasize: ["cross-currency conversion", "5%"] },
-        { text: "Do not include zkp2p, crypto, or related terms in the memo", emphasize: ["zkp2p", "crypto"] }
-      ]
-    };
-    wiseVerifyConfig = {
-      authLink: "https://wise.com/all-transactions?direction=OUTGOING",
-      actionType: "transfer_wise",
-      actionPlatform: "wise",
-      numPaymentsFetched: 20,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(Number(params.completedDate));
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        const amount = formatMajorAmountFromMinor2(
-          Number(params.amount.replace("-", "")),
-          params.currency
-        );
-        return {
-          amount,
-          date: formattedDate,
-          currency: params.currency,
-          paymentPlatform: PaymentPlatform.WISE,
-          paymentId: params.id,
-          recipient: params.username,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountParts = (metadata.amount ?? "").split(" ");
-          const currency = amountParts.pop() || metadata.currency || "";
-          let amountStr = amountParts.join("").replace(/\s+/g, "");
-          if (amountStr) {
-            if (amountStr.includes(",") && amountStr.includes(".")) {
-              const lastCommaIndex = amountStr.lastIndexOf(",");
-              const lastDotIndex = amountStr.lastIndexOf(".");
-              if (lastCommaIndex > lastDotIndex) {
-                amountStr = amountStr.replace(/\./g, "").replace(",", ".");
-              } else {
-                amountStr = amountStr.replace(/,/g, "");
-              }
-            } else if (amountStr.includes(",")) {
-              amountStr = amountStr.replace(",", ".");
-            }
-          }
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: metadata.date ?? "",
-            parsedDate: metadata.date ? true : false,
-            recipientId: String(metadata.recipient ?? "").replace(/<[^>]*>?/gm, ""),
-            parsedRecipientId: false,
-            // cause above is name and not wisetag
-            currency,
-            parsedCurrency: currency !== ""
-          };
-        } catch (error) {
-          console.error("Error parsing Wise metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        const recipient = String(metadata.recipient ?? "").replace(/<[^>]*>?/gm, "");
-        const amount = String(metadata.amount ?? "").replace(/<[^>]*>?/gm, "");
-        return `Sent ${amount} to ${recipient}`;
-      }
-    };
-    wiseDepositConfig = {
-      depositRequiresApproval: true,
-      payeeDetailInputPlaceholder: "Enter your Wisetag without @",
-      payeeDetailInputHelperText: "This is your Wisetag. Do not include the @ symbol.",
-      payeeDetailValidationFailureMessage: "Make sure there are no typos. Do not include the @ symbol.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          wisetag: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.wisetag;
-      }
-    };
-    wiseConfig = {
-      platformId: PaymentPlatform.WISE,
-      platformName: "Wise",
-      platformLogo: "",
-      platformColor: "#163300",
-      // Wise's brand blue color
-      platformCurrencies: [
-        Currency.USD,
-        Currency.CNY,
-        Currency.EUR,
-        Currency.GBP,
-        Currency.AUD,
-        Currency.NZD,
-        Currency.CAD,
-        Currency.AED,
-        Currency.CHF,
-        Currency.ZAR,
-        Currency.SGD,
-        Currency.ILS,
-        Currency.HKD,
-        Currency.JPY,
-        Currency.PLN,
-        Currency.TRY,
-        Currency.IDR,
-        Currency.KES,
-        Currency.MYR,
-        Currency.MXN,
-        Currency.THB,
-        Currency.VND,
-        Currency.UGX,
-        // 29 July 2025
-        Currency.CZK,
-        Currency.DKK,
-        Currency.HUF,
-        Currency.INR,
-        Currency.NOK,
-        Currency.PHP,
-        Currency.RON,
-        Currency.SEK
-      ],
-      minFiatAmount: "0.1",
-      // 0.1 USD
-      localeTimeString: "en-US",
-      depositConfig: wiseDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: wiseSendConfig,
-          verifyConfig: wiseVerifyConfig
-        }
-      ]
-    };
-    mercadoPagoSendConfig = {
-      defaultPaymentMode: "WEB_PAYMENT",
-      useCustomQRCode: true,
-      payeeDetailPrefix: "CVU",
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://www.mercadopago.com.ar/money-out/transfer/`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `https://www.mercadopago.com.ar/money-out/transfer/`,
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `IMPORTANT: Only make payments through the Mercado Pago website. Do not use the mobile app.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Double check that the CVU matches exactly before sending the payment. Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: "Use the Mercado Pago website to send", emphasize: ["Mercado Pago website"] },
-        { text: "Double check that the CVU matches exactly", emphasize: ["exactly", "CVU"] },
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not use the mobile app for this payment", emphasize: ["Do not", "mobile app"] }
-      ]
-    };
-    mercadoPagoVerifyConfig = {
-      authLink: "https://www.mercadopago.com.ar/home",
-      actionType: "transfer_mercadopago",
-      actionPlatform: "mercadopago",
-      numPaymentsFetched: 20,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(params.date);
-        const formattedDate = date.toLocaleString("es-AR", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: false,
-          timeZone: "America/Argentina/Buenos_Aires"
-        });
-        const amount = Number(params.amt.replace("-", "")).toString();
-        return {
-          amount,
-          date: formattedDate,
-          currency: params.curr,
-          paymentPlatform: PaymentPlatform.MERCADO_PAGO,
-          paymentId: params.paymentId,
-          recipient: params.recipientId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          let amountStr = "";
-          const amountValue = String(metadata.amount ?? "");
-          if (amountValue) {
-            const isSentTransaction = amountValue.startsWith("-");
-            amountStr = isSentTransaction ? amountValue.substring(1) : amountValue;
-            amountStr = amountStr.replace(/\./g, "").replace(/,/g, ".");
-            amountStr = isSentTransaction ? amountStr : `-${amountStr}`;
-          }
-          const dateStr = new Date(metadata.date ?? "").toISOString();
-          return {
-            amount: amountStr,
-            parsedAmount: false,
-            // amountStr !== '',
-            date: dateStr,
-            parsedDate: false,
-            // dateStr !== '',
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "ARS",
-            parsedCurrency: false
-            // true,
-          };
-        } catch (error) {
-          console.error("Error parsing Mercado Pago metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        const amountValue = String(metadata.amount ?? "");
-        const sentTransaction = amountValue.includes("-");
-        if (sentTransaction) {
-          const amount = amountValue.replace("-", "");
-          return `Sent $ ${amount} to ${metadata.recipient}`;
-        } else {
-          return ``;
-        }
-      }
-    };
-    mercadoPagoDepositConfig = {
-      depositRequiresApproval: false,
-      payeeDetailInputPlaceholder: "Enter your Mercado Pago / Bank CVU",
-      payeeDetailInputHelperText: "This is your Mercado Pago CVU. You can find it in your Mercado Pago account.",
-      payeeDetailValidationFailureMessage: "Make sure there are no typos.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          cvu: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.cvu;
-      }
-    };
-    mercadoPagoConfig = {
-      platformId: PaymentPlatform.MERCADO_PAGO,
-      platformName: "Mercado Pago",
-      platformLogo: "",
-      platformColor: "#00B1EA",
-      // Mercado Pago's brand blue color
-      platformCurrencies: [Currency.ARS],
-      minFiatAmount: "1",
-      // 1 ARS
-      localeTimeString: "es-AR",
-      depositConfig: mercadoPagoDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: mercadoPagoSendConfig,
-          verifyConfig: mercadoPagoVerifyConfig
-        }
-      ]
-    };
-    encodeZelleRecipientId = (recipientId) => {
-      const payload = {
-        name: "",
-        action: "payment",
-        token: recipientId
-      };
-      return btoa(JSON.stringify(payload));
-    };
-    zelleBankOfAmericaSendConfig = {
-      paymentMethodName: "Bank of America",
-      paymentMethodIcon: void 0,
-      // Icon provided by client-side assets
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://www.bankofamerica.com/`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => {
-        return `https://www.bankofamerica.com/movemoney`;
-      },
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment through Bank of America's Zelle.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Only use Bank of America. Scan the QR code and manually enter the recipient email. Double-check the email before sending.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: "Use Bank of America", emphasize: ["Bank of America"] },
-        { text: "Scan the QR code and manually enter the recipient email", emphasize: ["manually", "recipient email"] },
-        { text: "Double-check the email before sending", emphasize: ["Double-check"] },
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not use any other bank", emphasize: ["Do not"] }
-      ]
-    };
-    zelleBankOfAmericaVerifyConfig = {
-      authLink: "https://www.bankofamerica.com/",
-      actionType: "transfer_zelle",
-      actionPlatform: "bankofamerica",
-      numPaymentsFetched: 15,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(Number(params.date));
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        return {
-          amount: params.amount,
-          date: formattedDate,
-          currency: params.currency_code,
-          paymentPlatform: PaymentPlatform.ZELLE,
-          paymentId: params.paymentId,
-          recipient: params.receiverId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountStr = metadata.amount ?? "";
-          let dateStr = metadata.date ?? "";
-          if (dateStr && dateStr.length === 10) {
-            dateStr = `${dateStr}T23:59:59`;
-          }
-          const recipientIdStr = metadata.recipient || "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: recipientIdStr,
-            parsedRecipientId: false,
-            currency: Currency.USD,
-            parsedCurrency: true
-          };
-        } catch (error) {
-          console.error("Error parsing Zelle Bank of America metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        if (!metadata.amount || !metadata.recipient) {
-          return "";
-        }
-        return `Transfer of $${Number(metadata.amount)} to ${metadata.recipient}`;
-      }
-    };
-    zelleChaseSendConfig = {
-      paymentMethodName: "Chase",
-      paymentMethodIcon: void 0,
-      // Icon provided by client-side assets
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://secure.chase.com/web/auth/dashboard#/dashboard/singleDoor/singleDoorController/index`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => {
-        const encodedRecipientId = encodeZelleRecipientId(recipientId);
-        return `https://enroll.zellepay.com/qr-codes?data=${encodedRecipientId}`;
-      },
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment through Chase's Zelle.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Do not send using any other bank.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: "Use Chase for this payment", emphasize: ["Chase"] },
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not send using any other bank", emphasize: ["Do not"] }
-      ]
-    };
-    zelleChaseVerifyConfig = {
-      authLink: "https://secure.chase.com/web/auth/dashboard#/dashboard/singleDoor/payments/activity;params=qp,sentactivity",
-      actionType: "transfer_zelle",
-      actionPlatform: "chase",
-      numPaymentsFetched: 15,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 2,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(Number(params.date));
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        return {
-          amount: params.amount,
-          date: formattedDate,
-          currency: params.currency_code,
-          paymentPlatform: PaymentPlatform.ZELLE,
-          paymentId: params.paymentId,
-          recipient: params.receiverId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountStr = metadata.amount ?? "";
-          let dateStr = metadata.date ?? "";
-          if (dateStr && dateStr.length === 8) {
-            const year = dateStr.substring(0, 4);
-            const month = dateStr.substring(4, 6);
-            const day = dateStr.substring(6, 8);
-            dateStr = `${year}-${month}-${day}T23:59:59`;
-          }
-          const recipientIdStr = metadata.recipient || "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: recipientIdStr,
-            parsedRecipientId: false,
-            currency: Currency.USD,
-            parsedCurrency: true
-          };
-        } catch (error) {
-          console.error("Error parsing Zelle Chase metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        if (!metadata.amount || !metadata.recipient) {
-          return "";
-        }
-        return `Transfer of $${Number(metadata.amount)} to ${metadata.recipient}`;
-      }
-    };
-    zelleCitiSendConfig = {
-      paymentMethodName: "Citi",
-      paymentMethodIcon: void 0,
-      // Icon provided by client-side assets
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://online.citi.com/US/nga/zelle/transfer`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => {
-        const encodedRecipientId = encodeZelleRecipientId(recipientId);
-        return `https://enroll.zellepay.com/qr-codes?data=${encodedRecipientId}`;
-      },
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment through Citi's Zelle.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Do not send using any other bank.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: "Use Citi for this payment", emphasize: ["Citi"] },
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not send using any other bank", emphasize: ["Do not"] }
-      ]
-    };
-    zelleCitiVerifyConfig = {
-      authLink: "https://online.citi.com/US/nga/zelle/transfer",
-      actionType: "transfer_zelle",
-      actionPlatform: "citi",
-      numPaymentsFetched: 15,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(Number(params.date));
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        return {
-          amount: params.amount,
-          date: formattedDate,
-          currency: params.currency_code,
-          paymentPlatform: PaymentPlatform.ZELLE,
-          paymentId: params.paymentId,
-          recipient: params.receiverId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountStr = metadata.amount ?? "";
-          let dateStr = metadata.date ?? "";
-          if (dateStr && dateStr.length === 8) {
-            const year = dateStr.substring(0, 4);
-            const month = dateStr.substring(4, 6);
-            const day = dateStr.substring(6, 8);
-            dateStr = `${year}-${month}-${day}T23:59:59`;
-          }
-          const recipientIdStr = metadata.recipient || "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: recipientIdStr,
-            parsedRecipientId: recipientIdStr !== "",
-            currency: Currency.USD,
-            parsedCurrency: true
-          };
-        } catch (error) {
-          console.error("Error parsing Zelle Citi metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        if (!metadata.amount || !metadata.recipient) {
-          return "";
-        }
-        return `Transfer of $${Number(metadata.amount)} to ${metadata.recipient}`;
-      }
-    };
-    zelleDepositConfig = {
-      depositRequiresApproval: false,
-      payeeDetailInputPlaceholder: "Enter your email",
-      payeeDetailInputHelperText: "This is the email you use with Zelle",
-      payeeDetailValidationFailureMessage: "Make sure there are no typos in your email",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          zelleEmail: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.zelleEmail;
-      }
-    };
-    zelleConfig = {
-      platformId: PaymentPlatform.ZELLE,
-      platformName: "Zelle",
-      platformLogo: "",
-      platformColor: "#6D1ED4",
-      // Zelle's brand purple color
-      platformCurrencies: [Currency.USD],
-      minFiatAmount: "0.1",
-      // 0.1 USD
-      localeTimeString: "en-US",
-      depositConfig: zelleDepositConfig,
-      hasMultiplePaymentMethods: true,
-      paymentMethods: [
-        // Ensure payment method identifiers are same as that stored on the contract
-        {
-          sendConfig: zelleChaseSendConfig,
-          verifyConfig: zelleChaseVerifyConfig
-        },
-        {
-          sendConfig: zelleBankOfAmericaSendConfig,
-          verifyConfig: zelleBankOfAmericaVerifyConfig
-        },
-        {
-          sendConfig: zelleCitiSendConfig,
-          verifyConfig: zelleCitiVerifyConfig
-        }
-      ]
-    };
-    paypalSendConfig = {
-      defaultPaymentMode: "WEB_PAYMENT",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://www.paypal.com/myaccount/transfer/homepage`,
-      // Mobile deep link into PayPal app
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `paypal://`,
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Make sure the "Your Send" amount is at least ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} after PayPal fees. Only personal PayPal accounts are supported (business/merchant accounts are not allowed).`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Ensure "Friends and Family" is selected as the recipient type. If "Goods and Services" is the only option, please DO NOT send the payment and report in the Help section. Please do not put zkp2p, crypto or any related terms in the payment notes or memo field.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: "Use a personal PayPal account", emphasize: ["personal"] },
-        { text: "Select Friends and Family", emphasize: ["Friends and Family"] },
-        { text: `Ensure Your Send is at least ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} after fees`, emphasize: ["at least", amountFiatToSend, currencyInfo[sendCurrency].currencyCode] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not use a business or merchant account", emphasize: ["business", "merchant"] },
-        { text: "Do not include zkp2p, crypto, or related terms in the memo", emphasize: ["zkp2p", "crypto"] },
-        { text: "Avoid cross-currency conversion. If you do send the wrong currency, a 5% penalty will be automatically applied.", emphasize: ["cross-currency", "5% penalty"] },
-        { text: "Do not send as Goods and Services. You will lose funds.", emphasize: ["Goods and Services", "lose funds"] }
-      ]
-    };
-    paypalVerifyConfig = {
-      authLink: "https://www.paypal.com/myaccount/activities/filter/?q=ZnJlZV90ZXh0X3NlYXJjaD0mc3RhcnRfZGF0ZT0yMDI1LTAxLTAxJmVuZF9kYXRlPTIwMzAtMTItMzEmdHlwZT0mc3RhdHVzPSZjdXJyZW5jeT0mZmlsdGVyX2lkPSZpc3N1YW5jZV9wcm9kdWN0X25hbWU9JmFzc2V0X25hbWVzPSZhc3NldF9zeW1ib2xzPQ",
-      actionType: "transfer_paypal",
-      actionPlatform: "paypal",
-      numPaymentsFetched: 10,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(params.date);
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        const amount = Number(params.amount).toString();
-        return {
-          amount,
-          date: formattedDate,
-          currency: params.currencyCode,
-          paymentPlatform: PaymentPlatform.PAYPAL,
-          paymentId: params.paymentId,
-          recipient: params.email,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountStr = String(metadata.amount ?? "").split(" ")[0].replace(/[^0-9.]/g, "");
-          const currencyStr = metadata.currency ?? "";
-          const dateStr = metadata.date ?? "";
-          const recipientIdStr = metadata.recipient || "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: recipientIdStr,
-            parsedRecipientId: recipientIdStr !== "",
-            currency: currencyStr,
-            parsedCurrency: currencyStr !== ""
-          };
-        } catch (error) {
-          console.error("Error parsing Paypal metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        const amountStr = String(metadata.amount ?? "").split(/\s+/)[0].replace(/[^0-9.]/g, "");
-        const currencyStr = metadata.currency ?? "";
-        if (metadata.type !== "SEND_MONEY_SENT") {
-          return "";
-        }
-        return `Sent ${amountStr} ${currencyStr} to ${metadata.recipient}`;
-      }
-    };
-    paypalDepositConfig = {
-      depositRequiresApproval: false,
-      payeeDetailInputPlaceholder: "Enter your Paypal email",
-      payeeDetailInputHelperText: "This is your Paypal email",
-      payeeDetailValidationFailureMessage: "Make sure there are no typos in your email.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          paypalEmail: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.paypalEmail;
-      }
-    };
-    paypalConfig = {
-      platformId: PaymentPlatform.PAYPAL,
-      platformName: "Paypal",
-      platformCurrencies: [
-        Currency.USD,
-        Currency.EUR,
-        Currency.GBP,
-        Currency.SGD,
-        Currency.NZD,
-        Currency.AUD,
-        Currency.CAD
-      ],
-      platformLogo: void 0,
-      // paypalLogo - Legal counsel advised not to use logo
-      platformColor: "#0070BA",
-      // Paypal's brand blue color
-      minFiatAmount: "0.1",
-      // 0.1 USD
-      localeTimeString: "en-US",
-      depositConfig: paypalDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: paypalSendConfig,
-          verifyConfig: paypalVerifyConfig
-        }
-      ]
-    };
-    monzoSendConfig = {
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://monzo.me/${recipientId}`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `https://monzo.me/${recipientId}`,
-      supportsSendingPaymentOnWeb: false,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Send ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Use the Monzo app to send payment. Do not pay via card.`;
-      },
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: "Use the Monzo app to send payment", emphasize: ["Monzo app"] },
-        { text: `Send exactly ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode} in a single payment`, emphasize: ["exactly", amountFiatToSend, currencyInfo[sendCurrency].currencyCode, "single"] }
-      ],
-      sendPaymentDonts: () => [
-        { text: "Do not pay via card", emphasize: ["Do not", "card"] }
-      ]
-    };
-    monzoVerifyConfig = {
-      authLink: "https://web.monzo.com/",
-      actionType: "transfer_monzo",
-      actionPlatform: "monzo",
-      numPaymentsFetched: 10,
-      minExtensionVersion: "0.2.1",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(params.completedDate);
-        const formattedDate = date.toLocaleString("en-GB", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        const amount = (Number(params.amount.replace("-", "")) / 100).toString();
-        return {
-          amount,
-          date: formattedDate,
-          currency: params.currency,
-          paymentPlatform: PaymentPlatform.MONZO,
-          paymentId: params.TX_ID,
-          recipient: params.userId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountUnits = Number(metadata.amount) * -1 / 100;
-          const amountStr = parseFloat(amountUnits.toFixed(2)).toString();
-          const currencyStr = metadata.currency ?? "";
-          const dateStr = metadata.date ?? "";
-          const recipientIdStr = metadata.recipient || "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: recipientIdStr,
-            parsedRecipientId: recipientIdStr !== "",
-            currency: currencyStr,
-            parsedCurrency: currencyStr !== ""
-          };
-        } catch (error) {
-          console.error("Error parsing Monzo metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        if (Number(metadata.amount) < 0 && metadata.recipientName && metadata.recipientName !== void 0 && metadata.recipientName !== "") {
-          const currencySymbol = currencyInfo[metadata.currency ?? ""]?.currencySymbol ?? "";
-          const monzoFormattedAmount = Number(metadata.amount) * -1 / 100;
-          return `Sent ${currencySymbol}${monzoFormattedAmount} to ${metadata.recipientName} `;
-        } else {
-          return ``;
-        }
-      },
-      reverseTransactionHistoryOrder: true
-    };
-    monzoDepositConfig = {
-      depositRequiresApproval: false,
-      payeeDetailInputPlaceholder: "Enter your Monzo.me username",
-      payeeDetailInputHelperText: "This is your Monzo.me username",
-      payeeDetailValidationFailureMessage: "Make sure there are no typos in your username.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          monzoMeUsername: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.monzoMeUsername;
-      }
-    };
-    monzoConfig = {
-      platformId: PaymentPlatform.MONZO,
-      platformName: "Monzo",
-      platformCurrencies: [
-        Currency.GBP
-      ],
-      platformLogo: "",
-      platformColor: "#112231",
-      minFiatAmount: "0.1",
-      // 0.1 GBP
-      localeTimeString: "en-GB",
-      depositConfig: monzoDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: monzoSendConfig,
-          verifyConfig: monzoVerifyConfig
-        }
-      ]
-    };
-    formatAmountFromCents = (cents) => {
-      return parseFloat((cents / 100).toFixed(2)).toString();
-    };
-    n26SendConfig = {
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://app.n26.com/`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `number26://`,
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentDos: (sendCurrency, amountFiatToSend) => [
-        { text: `Enter the recipient's IBAN. You can use any name for the recipient.`, emphasize: ["You can use any name for the recipient"] },
-        { text: `Send at least ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode}`, emphasize: [amountFiatToSend] }
-      ],
-      sendPaymentDonts: (sendCurrency, amountFiatToSend) => [
-        { text: `Do not send less than the required amount` },
-        { text: `Do not include zkp2p, crypto, or related terms in the memo` }
-      ]
-    };
-    n26VerifyConfig = {
-      authLink: "https://app.n26.com/",
-      actionType: "transfer_n26",
-      actionPlatform: "n26",
-      numPaymentsFetched: 1,
-      minExtensionVersion: "0.2.3",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(params.date);
-        const formattedDate = date.toLocaleString("en-US", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: true
-        });
-        const amount = formatAmountFromCents(Number(params.amount));
-        return {
-          amount,
-          date: formattedDate,
-          currency: params.currency,
-          paymentPlatform: PaymentPlatform.N26,
-          paymentId: params.paymentId,
-          recipient: params.recipientId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountStr = String(metadata.amount ?? "").split(" ")[0].replace(/[^0-9.]/g, "");
-          const currencyStr = metadata.currency ?? "";
-          const dateStr = metadata.date ?? "";
-          const recipientIdStr = metadata.recipient || "";
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: recipientIdStr,
-            parsedRecipientId: recipientIdStr !== "",
-            currency: currencyStr,
-            parsedCurrency: currencyStr !== ""
-          };
-        } catch (error) {
-          console.error("Error parsing N26 metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        const amountStr = formatAmountFromCents(
-          Number(
-            String(metadata.amount ?? "").split(/\s+/)[0].replace(/[^0-9.]/g, "")
-          )
-        );
-        const currencyStr = metadata.currency ?? "";
-        return `Sent ${amountStr} ${currencyStr} to ${metadata.recipient}`;
-      }
-    };
-    n26DepositConfig = {
-      depositRequiresApproval: false,
-      payeeDetailInputPlaceholder: "Enter your IBAN",
-      payeeDetailInputHelperText: "This is your IBAN. You may enter any valid IBAN.",
-      payeeDetailValidationFailureMessage: "Make sure there are no typos in your IBAN.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          iban: payeeDetails.replace(/\s/g, ""),
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.iban;
-      }
-    };
-    n26Config = {
-      platformId: PaymentPlatform.N26,
-      platformName: "N26",
-      platformCurrencies: [
-        Currency.EUR
-      ],
-      platformLogo: void 0,
-      // Logo provided by client-side assets
-      platformColor: "#121212",
-      // N26's brand black color
-      minFiatAmount: "0.1",
-      localeTimeString: "en-US",
-      depositConfig: n26DepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: n26SendConfig,
-          verifyConfig: n26VerifyConfig
-        }
-      ]
-    };
-    decodeUnicodeEscapes = (str) => {
-      return str.replace(
-        /\\\\u([0-9a-fA-F]{4})|\\u([0-9a-fA-F]{4})/g,
-        (_, doubleHex, singleHex) => String.fromCharCode(parseInt(doubleHex || singleHex, 16))
-      );
-    };
-    parseAlipayAmount = (amount) => {
-      if (!amount) return null;
-      const trimmed = amount.trim();
-      if (!trimmed.startsWith("-")) return null;
-      return trimmed.replace(/^-\s*/, "");
-    };
-    parseAlipayDate = (dateStr) => {
-      if (!dateStr) return "";
-      if (dateStr.includes("\uFFFD") || dateStr.includes("\uFFFD")) {
-        const timeMatch = dateStr.match(/(\d{1,2}:\d{2})/);
-        const today = /* @__PURE__ */ new Date();
-        const datePrefix = today.toISOString().split("T")[0];
-        return timeMatch ? `${datePrefix} ${timeMatch[1]}` : datePrefix;
-      }
-      return dateStr;
-    };
-    alipaySendConfig = {
-      defaultPaymentMode: "QR_CODE",
-      useCustomQRCode: true,
-      troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://www.alipay.com/`,
-      getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => `alipays://`,
-      supportsSendingPaymentOnWeb: true,
-      showTroubleScanningQRCodeLink: true,
-      sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
-        return `Make sure the "Your Send" amount is at least ${amountFiatToSend} ${currencyInfo[sendCurrency].currencyCode}.`;
-      },
-      sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
-        return `Ensure that you send the exact amount to the Alipay recipient.`;
-      }
-    };
-    alipayVerifyConfig = {
-      authLink: "https://www.alipay.com/",
-      actionType: "transfer_alipay",
-      actionPlatform: "alipay",
-      numPaymentsFetched: 1,
-      minExtensionVersion: "0.2.3",
-      supportsAppclip: false,
-      totalProofs: 1,
-      parseExtractedParameters: (context) => {
-        const contextObject = JSON.parse(context);
-        const params = contextObject.extractedParameters;
-        const date = new Date(params.date);
-        const formattedDate = date.toLocaleString("zh-CN", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-          hour: "numeric",
-          minute: "numeric",
-          hour12: false
-        });
-        const amount = Number(params.amount).toString();
-        return {
-          amount,
-          date: formattedDate,
-          currency: params.currency,
-          paymentPlatform: PaymentPlatform.ALIPAY,
-          paymentId: params.paymentId,
-          recipient: params.recipientId,
-          intentHash: contextObject.contextMessage,
-          providerHash: contextObject.providerHash
-        };
-      },
-      parseMetadata: (metadata) => {
-        try {
-          const amountStr = parseAlipayAmount(metadata.amount) ?? "";
-          const currencyStr = metadata.currency ?? "";
-          const dateStr = parseAlipayDate(metadata.date);
-          const recipientIdStr = decodeUnicodeEscapes(metadata.recipient || "");
-          return {
-            amount: amountStr,
-            parsedAmount: amountStr !== "",
-            date: dateStr,
-            parsedDate: dateStr !== "",
-            recipientId: recipientIdStr,
-            parsedRecipientId: recipientIdStr !== "",
-            currency: currencyStr,
-            parsedCurrency: currencyStr !== ""
-          };
-        } catch (error) {
-          console.error("Error parsing Alipay metadata", error);
-          return {
-            amount: "",
-            parsedAmount: false,
-            date: "",
-            parsedDate: false,
-            recipientId: "",
-            parsedRecipientId: false,
-            currency: "",
-            parsedCurrency: false
-          };
-        }
-      },
-      getSubjectText: (metadata) => {
-        const amountStr = parseAlipayAmount(metadata.amount) ?? metadata.amount ?? "";
-        const recipient = decodeUnicodeEscapes(metadata.recipient ?? "");
-        return `Sent ${amountStr} CNY to ${recipient}`;
-      }
-    };
-    alipayDepositConfig = {
-      depositRequiresApproval: true,
-      payeeDetailInputPlaceholder: "Enter your email or phone number",
-      payeeDetailInputHelperText: "This is your email or phone number",
-      payeeDetailValidationFailureMessage: "Make sure there are no typos in your email or phone number.",
-      getDepositData: (payeeDetails, telegramUsername) => {
-        return {
-          alipayId: payeeDetails,
-          telegramUsername: telegramUsername || ""
-        };
-      },
-      getPayeeDetail: (data) => {
-        return data.alipayId;
-      }
-    };
-    alipayConfig = {
-      platformId: PaymentPlatform.ALIPAY,
-      platformName: "Alipay",
-      platformCurrencies: [
-        Currency.CNY
-      ],
-      platformLogo: "",
-      platformColor: "#1677FF",
-      // Alipay's brand blue color
-      minFiatAmount: "0.1",
-      localeTimeString: "zh-CN",
-      depositConfig: alipayDepositConfig,
-      hasMultiplePaymentMethods: false,
-      paymentMethods: [
-        {
-          sendConfig: alipaySendConfig,
-          verifyConfig: alipayVerifyConfig
-        }
-      ]
-    };
-    ({
-      [PaymentPlatform.VENMO]: venmoConfig,
-      [PaymentPlatform.CASHAPP]: cashappConfig,
-      [PaymentPlatform.CHIME]: chimeConfig,
-      [PaymentPlatform.REVOLUT]: revolutConfig,
-      [PaymentPlatform.ZELLE]: zelleConfig,
-      [PaymentPlatform.PAYPAL]: paypalConfig,
-      [PaymentPlatform.WISE]: wiseConfig,
-      [PaymentPlatform.MERCADO_PAGO]: mercadoPagoConfig,
-      [PaymentPlatform.MONZO]: monzoConfig,
-      [PaymentPlatform.N26]: n26Config,
-      [PaymentPlatform.ALIPAY]: alipayConfig
-    });
-    METHOD_NAME_TO_HASH = {
-      venmo: "0x90262a3db0edd0be2369c6b28f9e8511ec0bac7136cefbada0880602f87e7268",
-      revolut: "0x617f88ab82b5c1b014c539f7e75121427f0bb50a4c58b187a238531e7d58605d",
-      cashapp: "0x10940ee67cfb3c6c064569ec92c0ee934cd7afa18dd2ca2d6a2254fcb009c17d",
-      chime: "0x5908bb0c9b87763ac6171d4104847667e7f02b4c47b574fe890c1f439ed128bb",
-      wise: "0x554a007c2217df766b977723b276671aee5ebb4adaea0edb6433c88b3e61dac5",
-      mercadopago: "0xa5418819c024239299ea32e09defae8ec412c03e58f5c75f1b2fe84c857f5483",
-      "zelle-citi": "0x817260692b75e93c7fbc51c71637d4075a975e221e1ebc1abeddfabd731fd90d",
-      "zelle-chase": "0x6aa1d1401e79ad0549dced8b1b96fb72c41cd02b32a7d9ea1fed54ba9e17152e",
-      "zelle-bofa": "0x4bc42b322a3ad413b91b2fde30549ca70d6ee900eded1681de91aaf32ffd7ab5",
-      paypal: "0x3ccc3d4d5e769b1f82dc4988485551dc0cd3c7a3926d7d8a4dde91507199490f",
-      monzo: "0x62c7ed738ad3e7618111348af32691b5767777fbaf46a2d8943237625552645c",
-      n26: "0xd9ff4fd6b39a3e3dd43c41d05662a5547de4a878bc97a65bcb352ade493cdc6b",
-      alipay: "0xcac9daea62d7b89d75ac73af4ee14dcf25721012ae82b568c2ea5c808eaa04ff"
-    };
-    Object.entries(METHOD_NAME_TO_HASH).reduce(
-      (acc, [name, hash]) => {
-        acc[hash.toLowerCase()] = name;
-        return acc;
-      },
-      {}
-    );
-    BigInt(5e9);
-    BigInt(1e9);
-    BigInt(2e9);
-    usdcUnits(0.1);
-  }
-});
-
-// src/utils/keccak.ts
-var init_keccak = __esm({
-  "src/utils/keccak.ts"() {
-    init_utils();
   }
 });
 
@@ -2604,7 +361,7 @@ function resolvePaymentMethodNameFromHash(hash, catalog) {
 var init_paymentResolution = __esm({
   "src/utils/paymentResolution.ts"() {
     init_bytes32();
-    init_keccak();
+    init_currencyKeccak256();
   }
 });
 
@@ -2672,7 +429,7 @@ function isSupportedCurrencyHash(hash) {
 exports.Currency = void 0; exports.currencyInfo = void 0;
 var init_currency = __esm({
   "src/utils/currency.ts"() {
-    init_keccak();
+    init_currencyKeccak256();
     exports.Currency = {
       AED: "AED",
       ARS: "ARS",
@@ -3131,6 +888,7 @@ var DEPOSIT_FIELDS = `
   escrowAddress
   depositId
   depositor
+  delegate
   token
   remainingDeposits
   intentAmountMin
@@ -3471,6 +1229,7 @@ function groupByDepositId(items) {
 }
 var DEFAULT_LIMIT = 100;
 var DEFAULT_ORDER_FIELD = "remainingDeposits";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var IndexerDepositService = class {
   constructor(client) {
     this.client = client;
@@ -3480,6 +1239,11 @@ var IndexerDepositService = class {
     const where = {};
     if (filter.status) where.status = { _eq: filter.status };
     if (filter.depositor) where.depositor = { _ilike: filter.depositor };
+    if (filter.delegate) {
+      where.delegate = { _ilike: filter.delegate };
+    } else if (filter.delegateIsSet !== void 0) {
+      where.delegate = filter.delegateIsSet ? { _neq: ZERO_ADDRESS } : { _eq: ZERO_ADDRESS };
+    }
     if (filter.chainId) where.chainId = { _eq: filter.chainId };
     if (filter.escrowAddresses && filter.escrowAddresses.length) {
       where.escrowAddress = { _in: filter.escrowAddresses };
@@ -3791,7 +1555,8 @@ init_errors();
 function createHeaders(apiKey, authToken) {
   const headers2 = { "Content-Type": "application/json" };
   if (apiKey) headers2["x-api-key"] = apiKey;
-  if (authToken) headers2["Authorization"] = authToken.startsWith("Bearer ") ? authToken : `Bearer ${authToken}`;
+  if (authToken)
+    headers2["Authorization"] = authToken.startsWith("Bearer ") ? authToken : `Bearer ${authToken}`;
   return headers2;
 }
 function withApiBase(baseApiUrl) {
@@ -3812,26 +1577,31 @@ async function apiFetch({
   retryDelayMs = 1e3
 }) {
   const endpoint = url.replace(/^[^/]*\/\/[^/]*/, "");
-  return withRetry(async () => {
-    let res;
-    try {
-      const options = {
-        method,
-        headers: createHeaders(apiKey, authToken)
-      };
-      if (body && method !== "GET") {
-        options.body = JSON.stringify(body);
+  return withRetry(
+    async () => {
+      let res;
+      try {
+        const options = {
+          method,
+          headers: createHeaders(apiKey, authToken)
+        };
+        if (body && method !== "GET") {
+          options.body = JSON.stringify(body);
+        }
+        res = await fetch(url, options);
+      } catch (error) {
+        throw new exports.NetworkError("Failed to connect to API server", { endpoint, error });
       }
-      res = await fetch(url, options);
-    } catch (error) {
-      throw new exports.NetworkError("Failed to connect to API server", { endpoint, error });
-    }
-    if (!res.ok) {
-      const errorText = await res.text();
-      throw parseAPIError(res, errorText);
-    }
-    return res.json();
-  }, retryCount, retryDelayMs, timeoutMs);
+      if (!res.ok) {
+        const errorText = await res.text();
+        throw parseAPIError(res, errorText);
+      }
+      return res.json();
+    },
+    retryCount,
+    retryDelayMs,
+    timeoutMs
+  );
 }
 function processApiResponse(data, transformDates = true) {
   if (!transformDates) return data;
@@ -3904,7 +1674,13 @@ async function apiValidatePayeeDetails(req, baseApiUrl, timeoutMs) {
   return data;
 }
 function transformDatesToObjects(obj) {
-  const dateFields = ["createdAt", "updatedAt", "signalTimestamp", "fulfillTimestamp", "prunedTimestamp"];
+  const dateFields = [
+    "createdAt",
+    "updatedAt",
+    "signalTimestamp",
+    "fulfillTimestamp",
+    "prunedTimestamp"
+  ];
   const transformed = { ...obj };
   for (const key in transformed) {
     const value = transformed[key];
@@ -3950,7 +1726,7 @@ async function apiGetTakerTier(req, apiKey, baseApiUrl, authToken, timeoutMs) {
 // src/client/Zkp2pClient.ts
 init_contracts();
 init_paymentResolution();
-init_keccak();
+init_currencyKeccak256();
 
 // src/utils/erc20.ts
 var ERC20_ABI = [