@anywalletkit/protocol-swap2-chainflip 0.4.6 → 0.4.8

package/dist/index.js

@@ -1,13 +1,13 @@
 import {
   ChainflipSwap2Protocol
-} from "./chunk-RRCQYT67.js";
+} from "./chunk-G5FZLGMT.js";
 import {
   chainflipProvider
-} from "./chunk-RU2NXJTL.js";
+} from "./chunk-XUMGQNH4.js";
 import {
   CHAINFLIP_MODULE,
   describeChainflipActivity
-} from "./chunk-ZH5XKSCP.js";
+} from "./chunk-C2OITXU4.js";
 import {
   CF_API_DEFAULT,
   CF_ASSETS,
@@ -18,7 +18,7 @@ import {
   chainflip,
   chainflipPins,
   chainflipVerifyQuote
-} from "./chunk-DGLXKJQ7.js";
+} from "./chunk-IQSAPDND.js";
 import {
   decodeCfParameters,
   decodeEvmVaultCall,

package/dist/protocol.cjs

@@ -25,6 +25,9 @@ __export(protocol_exports, {
 module.exports = __toCommonJS(protocol_exports);
 var import_single = require("@anywalletkit/protocol-swap2-core/swap2/single");
 
+// src/config.ts
+var import_errors = require("@anywalletkit/protocol-swap2-core/errors");
+
 // src/codec.ts
 var import_base = require("@scure/base");
 var import_sha2 = require("@noble/hashes/sha2.js");
@@ -205,50 +208,69 @@ var chainflip = {
   supportsChain: (chain) => !!CF_CHAINS[chain],
   supports: (from, to) => CF_SOURCE_CHAINS.has(from) && !!CF_CHAINS[to] && from !== to
 };
+var notes = (0, import_errors.refusalNotes)();
+var unparsed = /* @__PURE__ */ new Set();
+function decodeFailure(text, requestParsed) {
+  unparsed.delete(text);
+  if (requestParsed) return notes.note(text, "upstream_unavailable");
+  unparsed.add(text);
+  if (unparsed.size > 64) unparsed.delete(unparsed.values().next().value);
+  return text;
+}
+var reasonOf = (text) => unparsed.has(text) ? void 0 : notes.reasonOf(text);
 function chainflipVerifyQuote(params, quote) {
+  let readingRequest = false;
   try {
     const src = cfAsset(params.sourceChain, params.sourceToken);
     const dst = cfAsset(params.destChain, params.destToken);
     const dstChain = CF_CHAINS[params.destChain];
     const vault = Object.prototype.hasOwnProperty.call(CF_VAULTS, params.sourceChain) ? CF_VAULTS[params.sourceChain] : void 0;
-    if (!src || !dst || !dstChain || !vault || !CF_SOURCE_CHAINS.has(params.sourceChain)) return "not a vault swap this release signs";
+    if (!src || !dst || !dstChain || !vault || !CF_SOURCE_CHAINS.has(params.sourceChain)) return notes.note("not a vault swap this release signs", "unsupported_pair");
     if (!quote.txRequest && !quote.depositAddress) return null;
-    if (!params.refundAddress) return "a live quote needs the refund address";
+    if (!params.refundAddress) return notes.note("a live quote needs the refund address", "policy_refused");
+    readingRequest = true;
     const amountIn = BigInt(params.amountIn);
     const dest = destAddressBytes(params.destChain, params.destAddress);
     const refund = destAddressBytes(params.sourceChain, params.refundAddress);
+    readingRequest = false;
     const checkParams = (p) => {
-      if (!sameBytes(fromHex(p.refundAddress), refund)) return "the refund address is not the sender";
-      if (minOutOf(amountIn, p.minPriceX128) < BigInt(quote.minDestAmount)) return "the minimum price does not guarantee the quoted minimum";
-      if (p.dca !== null || p.boostFeeBps !== 0 || p.broker.feeBps !== 0 || p.affiliates.length) return "DCA, boost, a broker fee or affiliates";
+      if (!sameBytes(fromHex(p.refundAddress), refund)) return notes.note("the refund address is not the sender", "recipient_mismatch");
+      if (minOutOf(amountIn, p.minPriceX128) < BigInt(quote.minDestAmount)) return notes.note("the minimum price does not guarantee the quoted minimum", "price_check_failed");
+      if (p.dca !== null || p.boostFeeBps !== 0 || p.broker.feeBps !== 0 || p.affiliates.length) return notes.note("DCA, boost, a broker fee or affiliates", "policy_refused");
       return null;
     };
     if (params.sourceChain.startsWith("eip155:")) {
       const tx = quote.txRequest;
-      if (quote.depositAddress || !tx?.data || tx.serializedTx !== void 0) return "an EVM vault swap is a vault call, not a deposit";
-      if (!tx.to || tx.to.toLowerCase() !== vault.toLowerCase()) return `the call targets ${tx.to}, not the Vault`;
+      if (quote.depositAddress || !tx?.data || tx.serializedTx !== void 0) return notes.note("an EVM vault swap is a vault call, not a deposit", "policy_refused");
+      if (!tx.to || tx.to.toLowerCase() !== vault.toLowerCase()) return notes.note(`the call targets ${tx.to}, not the Vault`, "vault_mismatch");
       const v = decodeEvmVaultCall(tx.data);
-      if (v.dstChain !== dstChain.id || v.dstToken !== dst.id || !sameBytes(v.dstAddress, dest)) return "the vault call names another destination";
+      if (v.dstChain !== dstChain.id || v.dstToken !== dst.id || !sameBytes(v.dstAddress, dest)) return notes.note("the vault call names another destination", "recipient_mismatch");
       if (src.token === null) {
-        if (!v.native || BigInt(tx.value ?? "0") !== amountIn || tx.approvalAddress) return "the native vault call moves another amount";
+        if (!v.native || BigInt(tx.value ?? "0") !== amountIn || tx.approvalAddress) return notes.note("the native vault call moves another amount", "policy_refused");
       } else if (v.native || v.srcToken?.toLowerCase() !== src.token.toLowerCase() || v.amount !== amountIn || BigInt(tx.value ?? "0") !== 0n || tx.approvalAddress?.toLowerCase() !== vault.toLowerCase()) {
-        return "the token vault call moves another token or amount";
+        return notes.note("the token vault call moves another token or amount", "policy_refused");
       }
       return checkParams(v.params);
     }
-    if (quote.txRequest || quote.depositAddress !== vault || !quote.depositMemo) return "a Tron vault swap is a send to the Tron Vault with its note";
+    if (quote.txRequest || quote.depositAddress !== vault || !quote.depositMemo) {
+      return notes.note(
+        "a Tron vault swap is a send to the Tron Vault with its note",
+        quote.txRequest ? "policy_refused" : quote.depositAddress !== vault ? "vault_mismatch" : "recipient_unverifiable"
+      );
+    }
     const n = decodeTronNote(quote.depositMemo);
-    if (n.outputAsset !== dst.id || n.destTag !== dstChain.addrTag || !sameBytes(n.destAddress, dest)) return "the note names another destination";
+    if (n.outputAsset !== dst.id || n.destTag !== dstChain.addrTag || !sameBytes(n.destAddress, dest)) return notes.note("the note names another destination", "recipient_mismatch");
     return checkParams(n.params);
   } catch (e) {
-    return `the vault swap does not decode (${(e instanceof Error ? e.message : String(e)).slice(0, 120)})`;
+    return decodeFailure(`the vault swap does not decode (${(e instanceof Error ? e.message : String(e)).slice(0, 120)})`, !readingRequest);
   }
 }
 var chainflipPins = Object.freeze({
   callTargets: (chain) => chainflipVaultFor(chain),
   spenders: (chain) => chainflipVaultFor(chain),
   verifyQuote: chainflipVerifyQuote,
-  verifyBuild: (quote, tx) => quote.depositMemo && tx.memoEncoding !== "hex" ? "the Tron note is not sent as hex bytes" : null,
+  verifyBuild: (quote, tx) => quote.depositMemo && tx.memoEncoding !== "hex" ? notes.note("the Tron note is not sent as hex bytes", "policy_refused") : null,
+  reasonOf,
   depositAddressRoutes: true
 });
 function chainflipVaultFor(chain) {
@@ -270,6 +292,7 @@ function describeChainflipActivity(tx, ctx) {
 }
 
 // src/provider.ts
+var import_errors2 = require("@anywalletkit/protocol-swap2-core/errors");
 var import_util = require("@anywalletkit/protocol-swap2-core/util");
 var import_viem2 = require("viem");
 var QUOTE_TTL_MS = 6e4;
@@ -277,6 +300,25 @@ var RETRY_BLOCKS = 50;
 var MAX_RETRY_BLOCKS = 600;
 var ERC20 = (0, import_viem2.parseAbi)(["function transfer(address to, uint256 amount) returns (bool)"]);
 var INTENT_PREFIX = "cfvault:";
+var notes2 = (0, import_errors2.refusalNotes)();
+function backendRefusal(status, body, retryAfter) {
+  const http = (0, import_errors2.httpRefusal)(status, retryAfter);
+  const byStatus = http?.reason === "key_rejected" ? { reason: "upstream_unavailable", httpStatus: status } : http;
+  if (byStatus?.reason === "rate_limited") return byStatus;
+  const m = body?.message;
+  const said = typeof m === "string" ? backendReason(m) : void 0;
+  return said && said !== byStatus?.reason ? { reason: said } : byStatus;
+}
+function backendReason(message) {
+  if (/liquidity/i.test(message)) return "insufficient_liquidity";
+  if (/maximum (?:swap )?amount|above (?:the )?max|too (?:large|big|high)|exceeds? (?:the )?max/i.test(message)) return "amount_too_large";
+  if (/minimum (?:swap |deposit )?amount|below (?:the )?minimum|lower than (?:the )?(?:estimated|minimum)|too (?:small|low)/i.test(message)) return "amount_too_small";
+  if (/halt|paus|maintenance|disabled|suspend|not enabled/i.test(message)) return "chain_halted";
+  if (/rate.?limit|too many requests/i.test(message)) return "rate_limited";
+  if (/not supported|unsupported|unknown asset|invalid asset/i.test(message)) return "unsupported_pair";
+  if (/no (?:route|quote)|could not find/i.test(message)) return "no_route";
+  return void 0;
+}
 function chainflipProvider(config = {}) {
   config = Object.freeze({ ...config });
   const base = new URL(config.apiUrl ?? CF_API_DEFAULT).toString().replace(/\/$/, "");
@@ -288,18 +330,18 @@ function chainflipProvider(config = {}) {
         await new Promise((r) => setTimeout(r, 1200));
         continue;
       }
-      return { ok: res.ok, status: res.status, body };
+      return { ok: res.ok, status: res.status, body, retryAfter: res.headers?.get?.("retry-after") ?? null };
     }
   };
   const checkParams = (p, want) => {
-    if (!sameBytes(fromHex(p.refundAddress), want.refund)) return `refund address ${p.refundAddress} is not the sender`;
-    if (p.minPriceX128 < want.minPriceX128) return "minimum price is below the one requested";
-    if (p.retryDurationBlocks > MAX_RETRY_BLOCKS) return `retry window ${p.retryDurationBlocks} blocks is too long`;
-    if (p.maxOraclePriceSlippageBps !== want.oracle) return "oracle slippage guard differs from the request";
-    if (p.dca !== null) return "unexpected DCA parameters";
-    if (p.boostFeeBps !== 0) return "unexpected boost fee";
-    if (p.broker.feeBps !== 0) return `broker takes ${p.broker.feeBps} bps`;
-    if (p.affiliates.length) return "unexpected affiliates";
+    if (!sameBytes(fromHex(p.refundAddress), want.refund)) return notes2.note(`refund address ${p.refundAddress} is not the sender`, "recipient_mismatch");
+    if (p.minPriceX128 < want.minPriceX128) return notes2.note("minimum price is below the one requested", "price_check_failed");
+    if (p.retryDurationBlocks > MAX_RETRY_BLOCKS) return notes2.note(`retry window ${p.retryDurationBlocks} blocks is too long`, "policy_refused");
+    if (p.maxOraclePriceSlippageBps !== want.oracle) return notes2.note("oracle slippage guard differs from the request", "price_check_failed");
+    if (p.dca !== null) return notes2.note("unexpected DCA parameters", "policy_refused");
+    if (p.boostFeeBps !== 0) return notes2.note("unexpected boost fee", "policy_refused");
+    if (p.broker.feeBps !== 0) return notes2.note(`broker takes ${p.broker.feeBps} bps`, "policy_refused");
+    if (p.affiliates.length) return notes2.note("unexpected affiliates", "policy_refused");
     return null;
   };
   return {
@@ -315,16 +357,19 @@ function chainflipProvider(config = {}) {
     },
     async getQuote(params, signal) {
       const dry = params.dry !== false;
-      const refuse = (reason) => {
-        params.onRefusal?.(`chainflip: ${reason}`);
+      const refuse = (reason, why) => {
+        const info = typeof why === "string" ? { reason: why } : why;
+        if (info) params.onRefusal?.(`chainflip: ${reason}`, info);
+        else params.onRefusal?.(`chainflip: ${reason}`);
         return null;
       };
-      if (!chainflip.supports(params.sourceChain, params.destChain)) return refuse(`no vault swap ${params.sourceChain} \u2192 ${params.destChain}`);
+      const unreachable = () => signal?.aborted ? void 0 : "upstream_unavailable";
+      if (!chainflip.supports(params.sourceChain, params.destChain)) return refuse(`no vault swap ${params.sourceChain} \u2192 ${params.destChain}`, "unsupported_pair");
       const src = cfAsset(params.sourceChain, params.sourceToken);
       const dst = cfAsset(params.destChain, params.destToken);
-      if (!src || !dst) return refuse(`asset not listed (${params.sourceToken} on ${params.sourceChain} \u2192 ${params.destToken} on ${params.destChain})`);
+      if (!src || !dst) return refuse(`asset not listed (${params.sourceToken} on ${params.sourceChain} \u2192 ${params.destToken} on ${params.destChain})`, "unsupported_pair");
       const amountIn = BigInt(params.amountIn);
-      if (amountIn < src.minDeposit) return refuse(`below the minimum deposit (${src.minDeposit} ${src.asset})`);
+      if (amountIn < src.minDeposit) return refuse(`below the minimum deposit (${src.minDeposit} ${src.asset})`, "amount_too_small");
       let destBytes;
       try {
         destBytes = destAddressBytes(params.destChain, params.destAddress);
@@ -333,21 +378,23 @@ function chainflipProvider(config = {}) {
       }
       const qs = new URLSearchParams({ amount: params.amountIn, srcChain: src.chain, srcAsset: src.asset, destChain: dst.chain, destAsset: dst.asset, isVaultSwap: "true", isOnChain: "false", dcaV2Enabled: "false" });
       let q;
+      let answered;
       try {
         const r = await call(`/v2/quote?${qs.toString()}`, {}, signal);
-        if (!r.ok) return refuse(`quote ${r.status}: ${String(r.body?.message ?? "").slice(0, 160)}`);
+        if (!r.ok) return refuse(`quote ${r.status}: ${String(r.body?.message ?? "").slice(0, 160)}`, backendRefusal(r.status, r.body, r.retryAfter));
+        answered = r.body;
         q = r.body?.find((x) => x.type === "REGULAR") ?? r.body?.[0];
       } catch (e) {
-        return refuse(`quote failed: ${e.message.slice(0, 160)}`);
+        return refuse(`quote failed: ${e.message.slice(0, 160)}`, unreachable());
       }
-      if (!q?.egressAmount || !/^\d+$/.test(q.egressAmount)) return refuse("quote without an egress amount");
-      if (q.type && q.type !== "REGULAR") return refuse(`${q.type} quotes are not supported`);
+      if (!q?.egressAmount || !/^\d+$/.test(q.egressAmount)) return refuse("quote without an egress amount", Array.isArray(answered) && answered.length === 0 ? "no_route" : unreachable());
+      if (q.type && q.type !== "REGULAR") return refuse(`${q.type} quotes are not supported`, "unsupported_pair");
       const expected = BigInt(q.egressAmount);
       const slipBps = params.slippageBps ?? Math.round((q.recommendedSlippageTolerancePercent ?? 1) * 100);
       const byTolerance = expected * BigInt(1e4 - Math.min(9999, Math.max(0, slipBps))) / 10000n;
       const callerFloor = params.minAmountOut !== void 0 ? BigInt(params.minAmountOut) : void 0;
       const minOut = callerFloor === void 0 ? byTolerance : params.slippageBps !== void 0 && byTolerance > callerFloor ? byTolerance : callerFloor;
-      if (minOut > expected) return refuse(`floor ${minOut} above the expected output ${expected}`);
+      if (minOut > expected) return refuse(`floor ${minOut} above the expected output ${expected}`, "price_check_failed");
       const minPriceX128 = minPriceX128For(amountIn, minOut);
       const guaranteed = minOutOf(amountIn, minPriceX128);
       const oracle = config.maxOraclePriceSlippageBps !== void 0 ? config.maxOraclePriceSlippageBps : q.recommendedLivePriceSlippageTolerancePercent !== void 0 ? Math.round(q.recommendedLivePriceSlippageTolerancePercent * 100) : null;
@@ -365,7 +412,7 @@ function chainflipProvider(config = {}) {
         validUntilMs: Date.now() + QUOTE_TTL_MS
       };
       if (dry) return { ...common, intentId: `dry:${crypto.randomUUID()}`, depositAddress: "", depositMemo: null };
-      if (!params.refundAddress) return refuse("live quote without a refund address");
+      if (!params.refundAddress) return refuse("live quote without a refund address", "policy_refused");
       let refund;
       try {
         refund = destAddressBytes(params.sourceChain, params.refundAddress);
@@ -384,26 +431,26 @@ function chainflipProvider(config = {}) {
       let enc;
       try {
         const r = await call("/api/encodeVaultSwapData", { method: "POST", body: JSON.stringify(body) }, signal);
-        if (!r.ok) return refuse(`encode ${r.status}: ${String(r.body?.message ?? "").slice(0, 160)}`);
+        if (!r.ok) return refuse(`encode ${r.status}: ${String(r.body?.message ?? "").slice(0, 160)}`, backendRefusal(r.status, r.body, r.retryAfter));
         enc = r.body ?? {};
       } catch (e) {
-        return refuse(`encode failed: ${e.message.slice(0, 160)}`);
+        return refuse(`encode failed: ${e.message.slice(0, 160)}`, unreachable());
       }
       const want = { refund, minPriceX128, oracle };
       const vault = CF_VAULTS[params.sourceChain];
       const dstChain = CF_CHAINS[params.destChain];
       try {
         if (params.sourceChain.startsWith("eip155:")) {
-          if (!enc.to || enc.to.toLowerCase() !== vault.toLowerCase()) return refuse(`encoder targets ${enc.to}, not the ${src.chain} Vault`);
+          if (!enc.to || enc.to.toLowerCase() !== vault.toLowerCase()) return refuse(`encoder targets ${enc.to}, not the ${src.chain} Vault`, !enc.to ? unreachable() : "vault_mismatch");
           const v = decodeEvmVaultCall(enc.calldata ?? "0x");
-          if (v.dstChain !== dstChain.id || v.dstToken !== dst.id || !sameBytes(v.dstAddress, destBytes)) return refuse("encoded destination differs from the request");
+          if (v.dstChain !== dstChain.id || v.dstToken !== dst.id || !sameBytes(v.dstAddress, destBytes)) return refuse("encoded destination differs from the request", "recipient_mismatch");
           if (src.token === null) {
-            if (!v.native || BigInt(enc.value ?? "0") !== amountIn) return refuse("native vault call with a different amount");
+            if (!v.native || BigInt(enc.value ?? "0") !== amountIn) return refuse("native vault call with a different amount", "policy_refused");
           } else if (v.native || v.srcToken?.toLowerCase() !== src.token.toLowerCase() || v.amount !== amountIn || BigInt(enc.value ?? "0") !== 0n) {
-            return refuse("token vault call with a different token or amount");
+            return refuse("token vault call with a different token or amount", "policy_refused");
           }
           const bad2 = checkParams(v.params, want);
-          if (bad2) return refuse(bad2);
+          if (bad2) return refuse(bad2, notes2.reasonOf(bad2));
           return {
             ...common,
             intentId: `${INTENT_PREFIX}${params.sourceChain}`,
@@ -413,17 +460,18 @@ function chainflipProvider(config = {}) {
             providerData: { kind: "evm", srcAsset: String(src.id), dstAsset: String(dst.id) }
           };
         }
-        if (enc.to !== vault) return refuse(`encoder targets ${enc.to}, not the Tron Vault`);
-        if (!enc.note) return refuse("Tron vault swap without a note");
+        if (enc.to !== vault) return refuse(`encoder targets ${enc.to}, not the Tron Vault`, !enc.to ? unreachable() : "vault_mismatch");
+        if (!enc.note) return refuse("Tron vault swap without a note", "recipient_unverifiable");
         if (src.token !== null) {
-          if (enc.sourceTokenAddress !== src.token) return refuse(`source token ${enc.sourceTokenAddress} is not ${src.asset}`);
+          if (enc.sourceTokenAddress !== src.token) return refuse(`source token ${enc.sourceTokenAddress} is not ${src.asset}`, "policy_refused");
           const t = (0, import_viem2.decodeFunctionData)({ abi: ERC20, data: enc.calldata ?? "0x" });
-          if (!sameBytes(fromHex(String(t.args[0])), tronToBytes(vault)) || t.args[1] !== amountIn) return refuse("TRC-20 transfer is not the amount to the Vault");
+          const toVault = sameBytes(fromHex(String(t.args[0])), tronToBytes(vault));
+          if (!toVault || t.args[1] !== amountIn) return refuse("TRC-20 transfer is not the amount to the Vault", toVault ? "policy_refused" : "vault_mismatch");
         }
         const n = decodeTronNote(enc.note);
-        if (n.outputAsset !== dst.id || n.destTag !== dstChain.addrTag || !sameBytes(n.destAddress, destBytes)) return refuse("note names another destination");
+        if (n.outputAsset !== dst.id || n.destTag !== dstChain.addrTag || !sameBytes(n.destAddress, destBytes)) return refuse("note names another destination", "recipient_mismatch");
         const bad = checkParams(n.params, want);
-        if (bad) return refuse(bad);
+        if (bad) return refuse(bad, notes2.reasonOf(bad));
         return {
           ...common,
           intentId: `${INTENT_PREFIX}${params.sourceChain}`,
@@ -432,20 +480,20 @@ function chainflipProvider(config = {}) {
           providerData: { kind: "tron", memoEncoding: "hex", srcAsset: String(src.id), dstAsset: String(dst.id) }
         };
       } catch (e) {
-        return refuse(`encoder output does not decode: ${e.message.slice(0, 160)}`);
+        return refuse(`encoder output does not decode: ${e.message.slice(0, 160)}`, "upstream_unavailable");
       }
     },
     async buildDeposit(quote) {
       if (quote.providerData?.kind === "evm") {
         const tx = quote.txRequest;
-        if (!tx?.to || !tx.data) throw new Error("chainflip: quote has no vault call");
+        if (!tx?.to || !tx.data) throw (0, import_errors2.refusal)("policy_refused", "chainflip: quote has no vault call");
         return { chain: "", to: tx.to, value: tx.value ?? "0", data: tx.data, ...tx.chainId !== void 0 ? { chainId: tx.chainId } : {}, ...tx.approvalAddress ? { approvalAddress: tx.approvalAddress } : {} };
       }
       if (quote.providerData?.kind === "tron") {
-        if (!quote.depositAddress || !quote.depositMemo) throw new Error("chainflip: Tron quote without vault or note");
+        if (!quote.depositAddress || !quote.depositMemo) throw (0, import_errors2.refusal)("policy_refused", "chainflip: Tron quote without vault or note");
         return { chain: "", to: quote.depositAddress, value: quote.sourceAmount, memo: quote.depositMemo, memoEncoding: "hex" };
       }
-      throw new Error("chainflip: not a live vault-swap quote");
+      throw (0, import_errors2.refusal)("policy_refused", "chainflip: not a live vault-swap quote");
     },
     async trackIntent(ref) {
       if (!ref.sourceTxHash) return { state: "pending" };