@axonfi/sdk 0.8.0 → 0.10.0

package/README.md

@@ -238,8 +238,8 @@ Interact with DeFi and Web3 protocols (Uniswap, Aave, GMX, Ostium, etc.) from yo
 const result = await axon.execute({
   protocol: '0xUniswapRouter',
   callData: '0x...',
-  token: Token.USDC,
-  amount: 100,
+  tokens: [Token.USDC],
+  amounts: [100],
 });
 ```
 
@@ -268,8 +268,8 @@ const OSTIUM_TRADING_STORAGE = '0x...'; // pulls USDC via transferFrom()
 await axon.execute({
   protocol: USDC,                    // call target: the token contract itself
   callData: encodeApprove(OSTIUM_TRADING_STORAGE, MaxUint256),
-  token: USDC,
-  amount: 0,                         // no token spend, just setting an allowance
+  tokens: [USDC],
+  amounts: [0],                      // no token spend, just setting an allowance
   protocolName: 'USDC Approve',
 });
 
@@ -277,8 +277,8 @@ await axon.execute({
 await axon.execute({
   protocol: OSTIUM_TRADING,          // call target: the Trading contract
   callData: encodeOpenTrade(...),
-  token: USDC,
-  amount: 50_000_000,                // 50 USDC — passed for dashboard/AI visibility
+  tokens: [USDC],
+  amounts: [50_000_000],             // 50 USDC — passed for dashboard/AI visibility
   protocolName: 'Ostium',
 });
 ```

package/dist/index.cjs

@@ -18,7 +18,7 @@ var PAYMENT_INTENT_TYPEHASH = viem.keccak256(
 );
 var EXECUTE_INTENT_TYPEHASH = viem.keccak256(
   viem.stringToBytes(
-    "ExecuteIntent(address bot,address protocol,bytes32 calldataHash,address token,uint256 amount,uint256 value,address[] extraTokens,uint256[] extraAmounts,uint256 deadline,bytes32 ref)"
+    "ExecuteIntent(address bot,address protocol,bytes32 calldataHash,address[] tokens,uint256[] amounts,uint256 value,uint256 deadline,bytes32 ref)"
   )
 );
 var SWAP_INTENT_TYPEHASH = viem.keccak256(
@@ -153,11 +153,9 @@ var EXECUTE_INTENT_TYPES = {
     { name: "bot", type: "address" },
     { name: "protocol", type: "address" },
     { name: "calldataHash", type: "bytes32" },
-    { name: "token", type: "address" },
-    { name: "amount", type: "uint256" },
+    { name: "tokens", type: "address[]" },
+    { name: "amounts", type: "uint256[]" },
     { name: "value", type: "uint256" },
-    { name: "extraTokens", type: "address[]" },
-    { name: "extraAmounts", type: "uint256[]" },
     { name: "deadline", type: "uint256" },
     { name: "ref", type: "bytes32" }
   ]
@@ -211,11 +209,9 @@ async function signExecuteIntent(walletClient, vaultAddress, chainId, intent) {
       bot: intent.bot,
       protocol: intent.protocol,
       calldataHash: intent.calldataHash,
-      token: intent.token,
-      amount: intent.amount,
+      tokens: intent.tokens,
+      amounts: intent.amounts,
       value: intent.value,
-      extraTokens: intent.extraTokens,
-      extraAmounts: intent.extraAmounts,
       deadline: intent.deadline,
       ref: intent.ref
     }
@@ -726,30 +722,20 @@ var AxonVaultAbi = [
             "internalType": "bytes32"
           },
           {
-            "name": "token",
-            "type": "address",
-            "internalType": "address"
+            "name": "tokens",
+            "type": "address[]",
+            "internalType": "address[]"
           },
           {
-            "name": "amount",
-            "type": "uint256",
-            "internalType": "uint256"
+            "name": "amounts",
+            "type": "uint256[]",
+            "internalType": "uint256[]"
           },
           {
             "name": "value",
             "type": "uint256",
             "internalType": "uint256"
           },
-          {
-            "name": "extraTokens",
-            "type": "address[]",
-            "internalType": "address[]"
-          },
-          {
-            "name": "extraAmounts",
-            "type": "uint256[]",
-            "internalType": "uint256[]"
-          },
           {
             "name": "deadline",
             "type": "uint256",
@@ -2599,6 +2585,11 @@ var AxonVaultAbi = [
     "name": "TooManySpendingLimits",
     "inputs": []
   },
+  {
+    "type": "error",
+    "name": "TooManyTokens",
+    "inputs": []
+  },
   {
     "type": "error",
     "name": "UnexpectedETH",
@@ -3984,11 +3975,30 @@ var AxonClient = class {
    * - `"approved"`: fast path — txHash available immediately
    * - `"pending_review"`: AI scan or human review in progress — poll for status
    * - `"rejected"`: payment was rejected — reason field explains why
+   *
+   * If the vault doesn't hold enough of the payment token, the relayer returns
+   * `errorCode: 'SWAP_REQUIRED'`. The SDK automatically signs a SwapIntent and
+   * resubmits the payment with swap fields — no action needed from the caller.
    */
   async pay(input) {
     const intent = this._buildPaymentIntent(input);
     const signature = await signPayment(this.walletClient, this.vaultAddress, this.chainId, intent);
-    return this._submitPayment(intent, signature, input);
+    const result = await this._submitPayment(intent, signature, input);
+    if (result.status === "rejected" && result.errorCode === "SWAP_REQUIRED") {
+      const swapIntent = {
+        bot: this.botAddress,
+        toToken: intent.token,
+        // swap TO the payment token
+        minToAmount: intent.amount,
+        // need at least the payment amount
+        deadline: intent.deadline,
+        // same deadline
+        ref: intent.ref
+      };
+      const swapSig = await signSwapIntent(this.walletClient, this.vaultAddress, this.chainId, swapIntent);
+      return this._submitPaymentWithSwap(intent, signature, input, swapIntent, swapSig);
+    }
+    return result;
   }
   // ============================================================================
   // execute()
@@ -4224,15 +4234,30 @@ Timestamp: ${timestamp}`;
   }
   _buildExecuteIntent(input) {
     _rejectBurnAddress(input.protocol, "Protocol address");
+    const inputTokens = input.tokens ?? [];
+    const inputAmounts = input.amounts ?? [];
+    if (inputTokens.length !== inputAmounts.length) {
+      throw new Error(`tokens length (${inputTokens.length}) must match amounts length (${inputAmounts.length})`);
+    }
+    if (inputTokens.length > 5) {
+      throw new Error(`Too many tokens (${inputTokens.length}): maximum 5 allowed. Contact Axon if you need more.`);
+    }
+    const resolvedTokens = inputTokens.map((t) => resolveToken(t, this.chainId));
+    const zeroAddr = "0x0000000000000000000000000000000000000000";
+    for (const t of resolvedTokens) {
+      if (t.toLowerCase() === zeroAddr) throw new Error("Zero address not allowed in tokens array");
+    }
+    const uniqueTokens = new Set(resolvedTokens.map((t) => t.toLowerCase()));
+    if (uniqueTokens.size !== resolvedTokens.length) {
+      throw new Error("Duplicate token addresses in tokens array");
+    }
     return {
       bot: this.botAddress,
       protocol: input.protocol,
       calldataHash: viem.keccak256(input.callData),
-      token: resolveToken(input.token, this.chainId),
-      amount: parseAmount(input.amount, input.token, this.chainId),
+      tokens: resolvedTokens,
+      amounts: inputTokens.map((t, i) => parseAmount(inputAmounts[i], t, this.chainId)),
       value: input.value ?? 0n,
-      extraTokens: input.extraTokens ?? [],
-      extraAmounts: input.extraAmounts ?? [],
       deadline: input.deadline ?? this._defaultDeadline(),
       ref: this._resolveRef(input.memo, input.ref)
     };
@@ -4246,6 +4271,38 @@ Timestamp: ${timestamp}`;
       ref: this._resolveRef(input.memo, input.ref)
     };
   }
+  async _submitPaymentWithSwap(intent, signature, input, swapIntent, swapSignature) {
+    const idempotencyKey = generateUuid();
+    const body = {
+      // Routing
+      chainId: this.chainId,
+      vaultAddress: this.vaultAddress,
+      // Flat intent fields (matches relayer DTO)
+      bot: intent.bot,
+      to: intent.to,
+      token: intent.token,
+      amount: intent.amount.toString(),
+      deadline: intent.deadline.toString(),
+      ref: intent.ref,
+      signature,
+      // Swap fields
+      swapSignature,
+      swapToToken: swapIntent.toToken,
+      swapMinToAmount: swapIntent.minToAmount.toString(),
+      swapDeadline: swapIntent.deadline.toString(),
+      swapRef: swapIntent.ref,
+      // Off-chain metadata
+      idempotencyKey,
+      ...input.memo !== void 0 && { memo: input.memo },
+      ...input.resourceUrl !== void 0 && { resourceUrl: input.resourceUrl },
+      ...input.invoiceId !== void 0 && { invoiceId: input.invoiceId },
+      ...input.orderId !== void 0 && { orderId: input.orderId },
+      ...input.recipientLabel !== void 0 && { recipientLabel: input.recipientLabel },
+      ...input.metadata !== void 0 && { metadata: input.metadata },
+      ...input.x402Funding !== void 0 && { x402Funding: input.x402Funding }
+    };
+    return this._post(RELAYER_API.PAYMENTS, idempotencyKey, body);
+  }
   async _submitPayment(intent, signature, input) {
     const idempotencyKey = input.idempotencyKey ?? generateUuid();
     const body = {
@@ -4274,8 +4331,6 @@ Timestamp: ${timestamp}`;
   }
   async _submitExecute(intent, signature, input) {
     const idempotencyKey = input.idempotencyKey ?? generateUuid();
-    const fromToken = input.fromToken !== void 0 ? resolveToken(input.fromToken, this.chainId) : void 0;
-    const maxFromAmount = input.maxFromAmount !== void 0 ? parseAmount(input.maxFromAmount, input.fromToken ?? input.token, this.chainId) : void 0;
     const body = {
       chainId: this.chainId,
       vaultAddress: this.vaultAddress,
@@ -4283,17 +4338,14 @@ Timestamp: ${timestamp}`;
       bot: intent.bot,
       protocol: intent.protocol,
       calldataHash: intent.calldataHash,
-      token: intent.token,
-      amount: intent.amount.toString(),
+      tokens: intent.tokens,
+      amounts: intent.amounts.map((a) => a.toString()),
       value: intent.value.toString(),
       deadline: intent.deadline.toString(),
       ref: intent.ref,
       signature,
       // Protocol calldata
       callData: input.callData,
-      // Optional pre-swap
-      ...fromToken !== void 0 && { fromToken },
-      ...maxFromAmount !== void 0 && { maxFromAmount: maxFromAmount.toString() },
       // Off-chain metadata
       idempotencyKey,
       ...input.memo !== void 0 && { memo: input.memo },