@anywalletkit/protocol-swap2-core 0.4.0 → 0.5.0

package/dist/swap2/base.d.cts

@@ -1,4 +1,5 @@
 import { Swap2Protocol, Swap2ProtocolConfig, Swap2Options, Swap2Fee, Swap2Quote, Swap2Result, Swap2StatusOptions, Swap2StatusResult, BridgeOptions, BridgeResult, SwapOptions, SwapResult, Swap2SupportedChain, Swap2SupportedTokensOptions, Swap2SupportedToken } from '@anywalletkit/core';
+import { CcAsset } from '@anywalletkit/swap2-assets';
 import { QuoteParams, Quote, CrossChainProvider } from '../types.cjs';
 
 /**
@@ -83,9 +84,21 @@ interface Swap2EngineConfig extends Swap2ProtocolConfig {
      * check has passed, BEFORE any approval or signature. It receives a copy of
      * exactly what will be signed; throwing (the user cancelled) aborts with
      * nothing sent. A quote that expires while the gate is open is refused
-     * before the first approval.
+     * before the first approval. When the quote expires while the engine's own
+     * approval is being mined, the engine re-quotes once; if the fresh quote
+     * differs from the reviewed one (payload, gas, a worse output) the gate is
+     * called again with `requoted: true`, and throwing then revokes the allowance.
      */
     reviewExecution?: (plan: Swap2ExecutionPlan) => Promise<void> | void;
+    /**
+     * Accept tokens the swap catalog does not list, named by their contract (EVM) or mint (Solana):
+     * tokens the user added at their own risk. Off by default. The source token's decimals are read
+     * with the account's `getTokenInfo` (a `fromTokenDecimals` that disagrees is refused); an account
+     * without it must be given `fromTokenDecimals`. Only providers that trade any token (LI.FI,
+     * Uniswap, Balancer, Fynd, Jupiter) quote them, and they have no USD value: the router cannot
+     * judge their price, so show the user the amounts.
+     */
+    allowUnlistedTokens?: boolean;
 }
 /** What `swap2()` is about to sign, handed to {@link Swap2EngineConfig.reviewExecution}. */
 interface Swap2ExecutionPlan {
@@ -108,6 +121,12 @@ interface Swap2ExecutionPlan {
         amount: bigint;
         chainId?: number;
     }[];
+    /**
+     * `true` on a second review: the first quote expired while its approval was being mined, and
+     * the fresh one differs from what was reviewed (another payload, a worse output). The allowance
+     * is already in place, so `approvals` is empty; cancelling revokes it.
+     */
+    requoted?: true;
     /** The source leg exactly as the account will receive it. */
     source: {
         kind: "call";
@@ -193,8 +212,18 @@ declare abstract class BaseSwap2Protocol extends Swap2Protocol {
     protected protocolEnabled(): boolean;
     /** Pair-level capability used when discovery specifies both endpoints. */
     protected pairSupported(fromChain: string, toChain: string): boolean;
+    private unlistedAllowed;
+    /** The source asset the options name: the catalog's, or (allowUnlistedTokens) an unlisted one with its decimals. */
+    protected sourceAsset(options: Swap2Options): CcAsset | undefined;
+    private readonly unlistedDecimals;
+    /**
+     * Options ready to quote: with `allowUnlistedTokens`, an unlisted source token gets its decimals,
+     * read from the chain through the account (cached per token) — a caller's `fromTokenDecimals` that
+     * disagrees is refused. Listed tokens and every option otherwise pass through unchanged.
+     */
+    protected prepareOptions(options: Swap2Options): Promise<Swap2Options>;
     /** Swap2Options → the engine's QuoteParams (exact-in only). */
-    protected toParams(options: Swap2Options, dry: boolean): QuoteParams;
+    protected toParams(given: Swap2Options, dry: boolean): QuoteParams;
     private assertAccountChain;
     protected assertFeeConfig(config?: Swap2ProtocolConfig): void;
     protected assertFeeCaps(fees: readonly Swap2Fee[] | undefined, sourceAmount: bigint, sourceToken: string, config?: Swap2ProtocolConfig): void;

package/dist/swap2/base.d.ts

@@ -1,4 +1,5 @@
 import { Swap2Protocol, Swap2ProtocolConfig, Swap2Options, Swap2Fee, Swap2Quote, Swap2Result, Swap2StatusOptions, Swap2StatusResult, BridgeOptions, BridgeResult, SwapOptions, SwapResult, Swap2SupportedChain, Swap2SupportedTokensOptions, Swap2SupportedToken } from '@anywalletkit/core';
+import { CcAsset } from '@anywalletkit/swap2-assets';
 import { QuoteParams, Quote, CrossChainProvider } from '../types.js';
 
 /**
@@ -83,9 +84,21 @@ interface Swap2EngineConfig extends Swap2ProtocolConfig {
      * check has passed, BEFORE any approval or signature. It receives a copy of
      * exactly what will be signed; throwing (the user cancelled) aborts with
      * nothing sent. A quote that expires while the gate is open is refused
-     * before the first approval.
+     * before the first approval. When the quote expires while the engine's own
+     * approval is being mined, the engine re-quotes once; if the fresh quote
+     * differs from the reviewed one (payload, gas, a worse output) the gate is
+     * called again with `requoted: true`, and throwing then revokes the allowance.
      */
     reviewExecution?: (plan: Swap2ExecutionPlan) => Promise<void> | void;
+    /**
+     * Accept tokens the swap catalog does not list, named by their contract (EVM) or mint (Solana):
+     * tokens the user added at their own risk. Off by default. The source token's decimals are read
+     * with the account's `getTokenInfo` (a `fromTokenDecimals` that disagrees is refused); an account
+     * without it must be given `fromTokenDecimals`. Only providers that trade any token (LI.FI,
+     * Uniswap, Balancer, Fynd, Jupiter) quote them, and they have no USD value: the router cannot
+     * judge their price, so show the user the amounts.
+     */
+    allowUnlistedTokens?: boolean;
 }
 /** What `swap2()` is about to sign, handed to {@link Swap2EngineConfig.reviewExecution}. */
 interface Swap2ExecutionPlan {
@@ -108,6 +121,12 @@ interface Swap2ExecutionPlan {
         amount: bigint;
         chainId?: number;
     }[];
+    /**
+     * `true` on a second review: the first quote expired while its approval was being mined, and
+     * the fresh one differs from what was reviewed (another payload, a worse output). The allowance
+     * is already in place, so `approvals` is empty; cancelling revokes it.
+     */
+    requoted?: true;
     /** The source leg exactly as the account will receive it. */
     source: {
         kind: "call";
@@ -193,8 +212,18 @@ declare abstract class BaseSwap2Protocol extends Swap2Protocol {
     protected protocolEnabled(): boolean;
     /** Pair-level capability used when discovery specifies both endpoints. */
     protected pairSupported(fromChain: string, toChain: string): boolean;
+    private unlistedAllowed;
+    /** The source asset the options name: the catalog's, or (allowUnlistedTokens) an unlisted one with its decimals. */
+    protected sourceAsset(options: Swap2Options): CcAsset | undefined;
+    private readonly unlistedDecimals;
+    /**
+     * Options ready to quote: with `allowUnlistedTokens`, an unlisted source token gets its decimals,
+     * read from the chain through the account (cached per token) — a caller's `fromTokenDecimals` that
+     * disagrees is refused. Listed tokens and every option otherwise pass through unchanged.
+     */
+    protected prepareOptions(options: Swap2Options): Promise<Swap2Options>;
     /** Swap2Options → the engine's QuoteParams (exact-in only). */
-    protected toParams(options: Swap2Options, dry: boolean): QuoteParams;
+    protected toParams(given: Swap2Options, dry: boolean): QuoteParams;
     private assertAccountChain;
     protected assertFeeConfig(config?: Swap2ProtocolConfig): void;
     protected assertFeeCaps(fees: readonly Swap2Fee[] | undefined, sourceAmount: bigint, sourceToken: string, config?: Swap2ProtocolConfig): void;

package/dist/swap2/base.js

@@ -7,7 +7,7 @@ import {
   nativeUnits,
   normalizeTypedDomain,
   swap2ChainId
-} from "../chunk-W2PHJINC.js";
+} from "../chunk-IC3MZIMB.js";
 import "../chunk-IVR3SREQ.js";
 export {
   BaseSwap2Protocol,

package/dist/swap2/single.cjs

@@ -195,6 +195,10 @@ function normalizeTypedDomain(domain) {
   return chainId === void 0 || !Number.isSafeInteger(chainId) ? domain : { ...domain, chainId };
 }
 var DEFAULT_SERIALIZED_NATIVE_ALLOWANCE = 20000000n;
+function reviewedIdentity(plan) {
+  const { feeUsd: _fee, etaSeconds: _eta, validUntilMs: _valid, approvals: _approvals, destAmount: _dest, requoted: _requoted, ...pinned } = plan;
+  return JSON.stringify(pinned, (_k, v) => typeof v === "bigint" ? v.toString() : v);
+}
 var SWAP2_ID_PREFIX = "awk1";
 function encodeId(provider, intentId, sourceTxHash) {
   const enc = (v) => encodeURIComponent(v).replace(/\./g, "%2E");
@@ -269,10 +273,11 @@ function toSymbol(caip2, ref) {
   if ((0, import_swap2_assets.ccAsset)(caip2, ref)) return ref;
   return ref;
 }
-function toDestAddress(caip2, ref) {
+function toDestAddress(caip2, ref, allowUnlisted = false) {
   if (ref.startsWith("0x")) return ref;
   const asset = (0, import_swap2_assets.ccAssetByToken)(caip2, ref) ?? (0, import_swap2_assets.ccAsset)(caip2, ref);
   if (!asset) {
+    if (allowUnlisted && (0, import_swap2_assets.isTokenAddress)(caip2, ref)) return ref;
     throw new Error(`swap2: unknown destination token '${ref}' on ${caip2}`);
   }
   return asset.contract ?? ZERO;
@@ -354,6 +359,15 @@ function mapStatus(s) {
   const status = s.state === "completed" ? "completed" : s.state === "action-required" ? "action-required" : s.state === "refund-pending" ? "refund-pending" : s.state === "partial" ? "partial" : s.state === "failed" ? "failed" : s.state === "refunded" ? "refunded" : s.state === "cancelled" ? "cancelled" : s.state === "expired" ? "expired" : "pending";
   return s.destTxHash ? { status, transactions: [{ hash: s.destTxHash, type: "destination" }] } : { status };
 }
+function blankToUndefined(v) {
+  return typeof v === "string" && v.trim() === "" ? void 0 : v;
+}
+function withoutBlankAddresses(o) {
+  const { recipient, refundAddress, ...rest } = o;
+  const r = blankToUndefined(recipient);
+  const f = blankToUndefined(refundAddress);
+  return { ...rest, ...r !== void 0 ? { recipient: r } : {}, ...f !== void 0 ? { refundAddress: f } : {} };
+}
 var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
   fromChain;
   constructor(account, config) {
@@ -386,19 +400,61 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
   pairSupported(fromChain, toChain) {
     return this.chainSupported(fromChain) && this.chainSupported(toChain);
   }
+  unlistedAllowed() {
+    return this._config.allowUnlistedTokens === true;
+  }
+  /** The source asset the options name: the catalog's, or (allowUnlistedTokens) an unlisted one with its decimals. */
+  sourceAsset(options) {
+    const decimals = options.fromTokenDecimals;
+    return (0, import_swap2_assets.resolveAsset)(this.fromChain, toSymbol(this.fromChain, options.fromToken), {
+      allowUnlisted: this.unlistedAllowed(),
+      ...decimals !== void 0 ? { decimals } : {}
+    });
+  }
+  unlistedDecimals = /* @__PURE__ */ new Map();
+  /**
+   * Options ready to quote: with `allowUnlistedTokens`, an unlisted source token gets its decimals,
+   * read from the chain through the account (cached per token) — a caller's `fromTokenDecimals` that
+   * disagrees is refused. Listed tokens and every option otherwise pass through unchanged.
+   */
+  async prepareOptions(options) {
+    if (!this.unlistedAllowed()) return options;
+    const ref = toSymbol(this.fromChain, options.fromToken);
+    if ((0, import_swap2_assets.resolveAsset)(this.fromChain, ref) || !(0, import_swap2_assets.isTokenAddress)(this.fromChain, ref)) return options;
+    const key = ref.startsWith("0x") ? ref.toLowerCase() : ref;
+    let decimals = this.unlistedDecimals.get(key);
+    if (decimals === void 0) {
+      const reader = this._account;
+      if (typeof reader?.getTokenInfo !== "function") {
+        if (options.fromTokenDecimals === void 0) {
+          throw new Swap2ValidationError(`swap2: '${ref}' is not in the catalog \u2014 pass fromTokenDecimals, or use an account that can read token info`);
+        }
+        return options;
+      }
+      decimals = (await reader.getTokenInfo(ref)).decimals;
+      this.unlistedDecimals.set(key, decimals);
+    }
+    if (options.fromTokenDecimals !== void 0 && options.fromTokenDecimals !== decimals) {
+      throw new Swap2ValidationError(`swap2: fromTokenDecimals ${options.fromTokenDecimals} does not match the token's ${decimals}`);
+    }
+    return snapshotOptions({ ...options, fromTokenDecimals: decimals });
+  }
   /** Swap2Options → the engine's QuoteParams (exact-in only). */
-  toParams(options, dry) {
+  toParams(given, dry) {
+    const options = withoutBlankAddresses(given);
     if (options.fromTokenAmount == null) {
       throw new Swap2UnsupportedOperationError("swap2: exact-out swap2 is not supported by the engine");
     }
     const destChain = toCaip2(options.toChain, this.fromChain);
     const constraints = callerConstraints(options);
     const amountIn = exactPositiveAmount(options.fromTokenAmount, "fromTokenAmount");
+    const source = this.sourceAsset(options);
     const params = {
       sourceChain: this.fromChain,
-      sourceToken: toSymbol(this.fromChain, options.fromToken),
+      sourceToken: (0, import_swap2_assets.isUnlisted)(source) ? source.contract : toSymbol(this.fromChain, options.fromToken),
+      ...(0, import_swap2_assets.isUnlisted)(source) ? { sourceDecimals: source.decimals } : {},
       destChain,
-      destToken: toDestAddress(destChain, options.toToken),
+      destToken: toDestAddress(destChain, options.toToken, this.unlistedAllowed()),
       amountIn: amountIn.toString(),
       destAddress: options.recipient ?? "",
       dry,
@@ -454,7 +510,7 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
     }
   }
   assertQuoteFeeCaps(q, options, config) {
-    const source = (0, import_swap2_assets.ccAsset)(this.fromChain, toSymbol(this.fromChain, options.fromToken));
+    const source = this.sourceAsset(options);
     if (!source) throw new Error(`swap2: unknown source token '${options.fromToken}' on ${this.fromChain}`);
     const token = source.contract ?? source.assetId;
     const fees = q.fees?.map((fee) => ({ ...fee, amount: BigInt(fee.amount) }));
@@ -499,7 +555,7 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
    * gave one.
    */
   async quoteSwap2(options) {
-    const snapshot = snapshotOptions(options);
+    const snapshot = await this.prepareOptions(snapshotOptions(options));
     const q = await this.resolveQuote(this.toParams(snapshot, true));
     if (!q) {
       const detail = this.noRouteDetail();
@@ -541,9 +597,9 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
     this.assertFeeConfig(configSnapshot);
     await this.assertAccountChain(signer);
     const selfAddress = await signer.getAddress();
-    const recipient = snapshot.recipient ?? selfAddress;
-    const refundAddress = snapshot.refundAddress ?? selfAddress;
-    const executionOptions = snapshotOptions({ ...snapshot, recipient, refundAddress });
+    const recipient = blankToUndefined(snapshot.recipient) ?? selfAddress;
+    const refundAddress = blankToUndefined(snapshot.refundAddress) ?? selfAddress;
+    const executionOptions = await this.prepareOptions(snapshotOptions({ ...snapshot, recipient, refundAddress }));
     const params = this.toParams(executionOptions, false);
     const resolved = await this.resolveQuote(params);
     if (!resolved) {
@@ -624,7 +680,7 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
     }
     let tokenId;
     if (!unsigned.data && !unsigned.bodyBoc && !unsigned.typedData && !serialized) {
-      const src = (0, import_swap2_assets.ccAsset)(this.fromChain, toSymbol(this.fromChain, executionOptions.fromToken));
+      const src = this.sourceAsset(executionOptions);
       if (src?.contract) {
         if (this.fromChain.startsWith("eip155:")) {
           unsigned = {
@@ -650,7 +706,7 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
     if (tokenId && (cellBody !== void 0 || unsigned.memo !== void 0 && !tronSource && !nearSource && !tonSource)) {
       throw new Error("swap2: token deposit with memo/cell payload is not implemented");
     }
-    const source = (0, import_swap2_assets.ccAsset)(this.fromChain, toSymbol(this.fromChain, executionOptions.fromToken));
+    const source = this.sourceAsset(executionOptions);
     if (!source) throw new Error(`swap2: unknown source token '${executionOptions.fromToken}' on ${this.fromChain}`);
     const executionValue = BigInt(unsigned.value);
     if (serialized) {
@@ -706,7 +762,8 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
       approvalAmounts = current === approvalAmount ? [] : [...usdtMainnet && current !== 0n ? [0n] : [], approvalAmount];
     }
     const review = this._config.reviewExecution;
-    if (review && !carried) {
+    let reviewed;
+    if (review && (!carried || carried.reviewed)) {
       const chainId = unsigned.chainId !== void 0 ? { chainId: unsigned.chainId } : {};
       const approvals = approvalAmounts.map((amount) => ({ token: source.contract, spender: unsigned.approvalAddress, amount, ...chainId }));
       const plan = {
@@ -734,12 +791,28 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
           ...cellBody !== void 0 ? { cellBody: true } : {}
         }
       };
-      await review(deepFreeze(structuredCloneSafe(plan)));
-      if (q.validUntilMs > 0 && q.validUntilMs <= Date.now()) {
-        throw new Swap2QuoteError("swap2: quote expired during review \u2014 nothing was signed");
+      const previous = carried?.reviewed;
+      if (!previous || reviewedIdentity(previous) !== reviewedIdentity(plan) || plan.destAmount < previous.destAmount) {
+        try {
+          reviewed = deepFreeze(structuredCloneSafe(previous ? { ...plan, requoted: true } : plan));
+          await review(reviewed);
+          if (q.validUntilMs > 0 && q.validUntilMs <= Date.now()) {
+            throw new Swap2QuoteError(`swap2: quote expired during review \u2014 ${previous ? "the allowance was revoked" : "nothing was signed"}`);
+          }
+        } catch (error) {
+          if (previous) await revokeApproval?.().catch(() => {
+          });
+          throw error;
+        }
       }
     }
-    await this.assertNativeGas(signer, unsigned, approvalAmounts, source.contract ?? void 0, !!unsigned.typedData || serialized || !!tokenId);
+    try {
+      await this.assertNativeGas(signer, unsigned, approvalAmounts, source.contract ?? void 0, !!unsigned.typedData || serialized || !!tokenId);
+    } catch (error) {
+      if (carried) await revokeApproval?.().catch(() => {
+      });
+      throw error;
+    }
     if (approvalAmounts.length) {
       const approve = async (amount) => {
         const sent2 = await signer.sendTransaction({
@@ -768,7 +841,7 @@ var BaseSwap2Protocol = class extends import_core.Swap2Protocol {
     if (q.validUntilMs > 0 && q.validUntilMs <= Date.now()) {
       if (!carried && approvalAmounts.length && revokeApproval) {
         this.emitPhase("requoting");
-        const handoff = { token: source.contract, spender: unsigned.approvalAddress, amount: approvalAmount, revoke: revokeApproval, adopted: false };
+        const handoff = { token: source.contract, spender: unsigned.approvalAddress, amount: approvalAmount, revoke: revokeApproval, adopted: false, ...reviewed ? { reviewed } : {} };
         try {
           return await this.executeSwap2(signer, snapshot, config, handoff);
         } catch (error) {