veilix-sdk 0.2.2 → 0.3.0

package/dist/react/index.js

@@ -40,7 +40,7 @@ function formatBaseUnits(value, decimals) {
 
 // src/idl/veilix-devnet.json
 var veilix_devnet_default = {
-  address: "HbatG5gpfs2g3N4gc2Qkfmmeu4zaBEVxzrDdYtWNLyyA",
+  address: "Vxi1QK84Akv4yGngjvkWNmEsK7XpsSrpDaPBoiyXGPG",
   metadata: {
     name: "veilix",
     version: "0.2.0",
@@ -641,6 +641,38 @@ var veilix_devnet_default = {
         {
           name: "system_program",
           address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
         }
       ],
       args: [
@@ -703,6 +735,91 @@ var veilix_devnet_default = {
             ]
           }
         },
+        {
+          name: "program_data",
+          docs: [
+            "This program's ProgramData. Only its upgrade authority may initialize the network,",
+            "so nobody can claim the config authority between deploy and setup."
+          ],
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  7,
+                  107,
+                  64,
+                  50,
+                  251,
+                  172,
+                  47,
+                  215,
+                  89,
+                  179,
+                  92,
+                  125,
+                  67,
+                  162,
+                  96,
+                  45,
+                  239,
+                  91,
+                  223,
+                  168,
+                  251,
+                  138,
+                  165,
+                  133,
+                  253,
+                  74,
+                  152,
+                  142,
+                  6,
+                  85,
+                  93,
+                  119
+                ]
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                2,
+                168,
+                246,
+                145,
+                78,
+                136,
+                161,
+                176,
+                226,
+                16,
+                21,
+                62,
+                247,
+                99,
+                174,
+                43,
+                0,
+                194,
+                185,
+                61,
+                22,
+                193,
+                36,
+                210,
+                192,
+                83,
+                122,
+                16,
+                4,
+                128,
+                0,
+                0
+              ]
+            }
+          }
+        },
         {
           name: "system_program",
           address: "11111111111111111111111111111111"
@@ -1031,6 +1148,31 @@ var veilix_devnet_default = {
             ]
           }
         },
+        {
+          name: "treasury",
+          docs: [
+            "Holds the SOL pool. Funded with its rent-exempt reserve here so that no withdrawal",
+            "can fail for leaving it below that reserve."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  116,
+                  114,
+                  101,
+                  97,
+                  115,
+                  117,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
         {
           name: "system_program",
           address: "11111111111111111111111111111111"
@@ -1426,38 +1568,368 @@ var veilix_devnet_default = {
       ],
       accounts: [
         {
-          name: "user",
-          signer: true
+          name: "user",
+          signer: true
+        },
+        {
+          name: "relayer",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  108,
+                  97,
+                  121,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "user"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "worker",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "swap",
+      docs: [
+        "Private swap. Remaining accounts: the protocol fee wallets for the input asset (SOL",
+        "accounts or their token accounts, in config order), then the DEX instruction's accounts."
+      ],
+      discriminator: [
+        248,
+        198,
+        158,
+        145,
+        225,
+        117,
+        135,
+        200
+      ],
+      accounts: [
+        {
+          name: "relayer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "relayer_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  108,
+                  97,
+                  121,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "relayer_account.owner",
+                account: "RelayerAccount"
+              }
+            ]
+          }
+        },
+        {
+          name: "network_state",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "swap_config",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  119,
+                  97,
+                  112,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "tree_in",
+          docs: [
+            "Tree of the asset being spent. The handler checks it is the PDA for its mint."
+          ],
+          writable: true
+        },
+        {
+          name: "tree_out",
+          docs: [
+            "Tree that receives the swapped note."
+          ],
+          writable: true
+        },
+        {
+          name: "treasury",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  116,
+                  114,
+                  101,
+                  97,
+                  115,
+                  117,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "escrow",
+          docs: [
+            "Signs the DEX call. Holds nothing between transactions."
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  119,
+                  97,
+                  112,
+                  95,
+                  101,
+                  115,
+                  99,
+                  114,
+                  111,
+                  119
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "treasury_ata_in",
+          docs: [
+            "Treasury ATA for `mint_in`. `None` when spending SOL."
+          ],
+          writable: true,
+          optional: true
+        },
+        {
+          name: "treasury_ata_out",
+          docs: [
+            "Treasury ATA for `mint_out`. `None` when receiving SOL."
+          ],
+          writable: true,
+          optional: true
+        },
+        {
+          name: "escrow_ata_in",
+          docs: [
+            "Escrow ATA for `mint_in` (wrapped SOL when spending SOL). Must exist: prepend an",
+            "idempotent ATA create. A wrapped-SOL escrow account is closed at the end of the swap."
+          ],
+          writable: true
+        },
+        {
+          name: "escrow_ata_out",
+          docs: [
+            "Escrow ATA for `mint_out` (wrapped SOL when receiving SOL). Must exist, as above."
+          ],
+          writable: true
+        },
+        {
+          name: "relayer_ata",
+          docs: [
+            "Relayer ATA for `mint_in`, paid the relayer fee. `None` when spending SOL."
+          ],
+          writable: true,
+          optional: true
+        },
+        {
+          name: "nullifier0",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  110,
+                  117,
+                  108,
+                  108,
+                  105,
+                  102,
+                  105,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "arg",
+                path: "proof.input_nullifiers [0]"
+              }
+            ]
+          }
+        },
+        {
+          name: "nullifier1",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  110,
+                  117,
+                  108,
+                  108,
+                  105,
+                  102,
+                  105,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "arg",
+                path: "proof.input_nullifiers [1]"
+              }
+            ]
+          }
+        },
+        {
+          name: "mint_in",
+          docs: [
+            "Mint of the spent asset (the native mint when spending SOL)."
+          ]
+        },
+        {
+          name: "mint_out",
+          docs: [
+            "Mint of the received asset (the native mint when receiving SOL)."
+          ]
+        },
+        {
+          name: "token_program_in"
+        },
+        {
+          name: "token_program_out"
+        },
+        {
+          name: "dex_program"
         },
         {
-          name: "relayer",
-          writable: true,
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
           pda: {
             seeds: [
               {
                 kind: "const",
                 value: [
-                  114,
+                  95,
+                  95,
                   101,
-                  108,
-                  97,
-                  121,
+                  118,
                   101,
-                  114
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
                 ]
-              },
-              {
-                kind: "account",
-                path: "user"
               }
             ]
           }
+        },
+        {
+          name: "program"
         }
       ],
       args: [
         {
-          name: "worker",
-          type: "pubkey"
+          name: "proof",
+          type: {
+            defined: {
+              name: "TransactionProof"
+            }
+          }
+        },
+        {
+          name: "params",
+          type: {
+            defined: {
+              name: "SwapParams"
+            }
+          }
+        },
+        {
+          name: "encrypted_output1",
+          type: "bytes"
+        },
+        {
+          name: "encrypted_output2",
+          type: "bytes"
+        },
+        {
+          name: "route_data",
+          type: "bytes"
         }
       ]
     },
@@ -1695,6 +2167,38 @@ var veilix_devnet_default = {
         {
           name: "system_program",
           address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
         }
       ],
       args: [
@@ -2061,6 +2565,38 @@ var veilix_devnet_default = {
         {
           name: "system_program",
           address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
         }
       ],
       args: [
@@ -2509,6 +3045,83 @@ var veilix_devnet_default = {
         }
       ]
     },
+    {
+      name: "update_swap_config",
+      docs: [
+        "Replaces the list of DEX programs the swap escrow may call. Config authority only."
+      ],
+      discriminator: [
+        123,
+        172,
+        158,
+        60,
+        104,
+        133,
+        39,
+        13
+      ],
+      accounts: [
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "network_state",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "swap_config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  119,
+                  97,
+                  112,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "allowed_programs",
+          type: {
+            vec: "pubkey"
+          }
+        }
+      ]
+    },
     {
       name: "withdraw",
       discriminator: [
@@ -2667,6 +3280,38 @@ var veilix_devnet_default = {
         {
           name: "system_program",
           address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
         }
       ],
       args: [
@@ -2776,6 +3421,19 @@ var veilix_devnet_default = {
         20
       ]
     },
+    {
+      name: "SwapConfig",
+      discriminator: [
+        212,
+        45,
+        70,
+        222,
+        245,
+        122,
+        125,
+        166
+      ]
+    },
     {
       name: "TreeAccount",
       discriminator: [
@@ -2817,6 +3475,19 @@ var veilix_devnet_default = {
         159
       ]
     },
+    {
+      name: "PrivateSwapEvent",
+      discriminator: [
+        150,
+        165,
+        138,
+        189,
+        123,
+        86,
+        117,
+        39
+      ]
+    },
     {
       name: "RelayerCancelled",
       discriminator: [
@@ -3076,9 +3747,59 @@ var veilix_devnet_default = {
       msg: "Relayer has earned fees in too many assets"
     },
     {
-      code: 6033,
-      name: "FeeRepaymentAccounts",
-      msg: "Fee repayment accounts do not match earned fees"
+      code: 6033,
+      name: "FeeRepaymentAccounts",
+      msg: "Fee repayment accounts do not match earned fees"
+    },
+    {
+      code: 6034,
+      name: "DexProgramNotAllowed",
+      msg: "DEX program is not on the swap allowlist"
+    },
+    {
+      code: 6035,
+      name: "TooManyDexPrograms",
+      msg: "Too many allowlisted DEX programs"
+    },
+    {
+      code: 6036,
+      name: "SlippageExceeded",
+      msg: "Swap output is below the minimum amount"
+    },
+    {
+      code: 6037,
+      name: "SwapInputMismatch",
+      msg: "DEX did not use exactly the escrowed swap input"
+    },
+    {
+      code: 6038,
+      name: "InvalidSwapAccounts",
+      msg: "Swap accounts do not match the trees"
+    },
+    {
+      code: 6039,
+      name: "EscrowTampered",
+      msg: "Swap escrow was modified by the DEX"
+    },
+    {
+      code: 6040,
+      name: "InvalidNoteKey",
+      msg: "Note public key or blinding is not a valid field element"
+    },
+    {
+      code: 6041,
+      name: "NotUpgradeAuthority",
+      msg: "Only the program upgrade authority can initialize the network"
+    },
+    {
+      code: 6042,
+      name: "InvalidFeeSplit",
+      msg: "Fee wallets must be distinct, non-default and split at most the allowed total"
+    },
+    {
+      code: 6043,
+      name: "UnsupportedMintExtension",
+      msg: "Token mint has an extension the pool does not support"
     }
   ],
   types: [
@@ -3259,6 +3980,68 @@ var veilix_devnet_default = {
         kind: "struct"
       }
     },
+    {
+      name: "PrivateSwapEvent",
+      docs: [
+        "Emitted once per swap. The asset-B note is `commitment` at `index` in the `mint_out` tree."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "mint_in",
+            type: "pubkey"
+          },
+          {
+            name: "mint_out",
+            type: "pubkey"
+          },
+          {
+            name: "amount_in",
+            type: "u64"
+          },
+          {
+            name: "fee",
+            type: "u64"
+          },
+          {
+            name: "amount_out",
+            type: "u64"
+          },
+          {
+            name: "input_nullifiers",
+            type: {
+              array: [
+                {
+                  array: [
+                    "u8",
+                    32
+                  ]
+                },
+                2
+              ]
+            }
+          },
+          {
+            name: "relayer",
+            type: "pubkey"
+          },
+          {
+            name: "commitment",
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "index",
+            type: "u64"
+          }
+        ]
+      }
+    },
     {
       name: "RelayerAccount",
       docs: [
@@ -3453,6 +4236,86 @@ var veilix_devnet_default = {
         ]
       }
     },
+    {
+      name: "SwapConfig",
+      docs: [
+        'Programs the swap escrow is allowed to call. PDA seeds: `["swap_config"]`.'
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "allowed_programs",
+            type: {
+              vec: "pubkey"
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "SwapParams",
+      docs: [
+        "Swap parameters. All of them are bound into the proof's `extDataHash`."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "amount_in",
+            docs: [
+              "Asset-A amount spent from the pool, fee included."
+            ],
+            type: "u64"
+          },
+          {
+            name: "fee",
+            docs: [
+              "Asset-A fee: protocol wallets get their split of `amount_in`, the relayer the rest."
+            ],
+            type: "u64"
+          },
+          {
+            name: "min_amount_out",
+            docs: [
+              "Minimum asset-B amount that must reach the treasury."
+            ],
+            type: "u64"
+          },
+          {
+            name: "out_pubkey",
+            docs: [
+              "One-time shielded public key of the asset-B note (32-byte big-endian field element)."
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "out_blinding",
+            docs: [
+              "Blinding of the asset-B note (32-byte big-endian field element)."
+            ],
+            type: {
+              array: [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            name: "encrypted_note",
+            docs: [
+              "Optional encrypted recovery data for the asset-B note."
+            ],
+            type: "bytes"
+          }
+        ]
+      }
+    },
     {
       name: "TransactionProof",
       docs: [
@@ -7351,7 +8214,7 @@ var MAINNET_TOKEN_MINTS = {
   USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
 };
 var DEVNET_TOKEN_MINTS = {
-  Veilix: "GAFN64LvtCBoc5BHncVn3JEJGpq42rUzQjPmvMK2UhZH",
+  Veilix: "Gmo636w21RBZX9ySVtPYcuYP6f1E5bdW5eBYhvK1bc8J",
   Bitcoin: "",
   Ethereum: "",
   USDC: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
@@ -7380,6 +8243,13 @@ var TOKEN_DECIMALS = {
   Bitcoin: 8,
   USDC: 6
 };
+var INDEXER_ASSET_LABELS = {
+  Solana: "SOL",
+  Veilix: "VEILIX",
+  Bitcoin: "WBTC",
+  Ethereum: "WETH",
+  USDC: "USDC"
+};
 function getTokenDecimals(symbol) {
   return TOKEN_DECIMALS[symbol];
 }
@@ -7394,7 +8264,7 @@ function getDepositQueueForNetwork(network) {
 // package.json
 var package_default = {
   name: "veilix-sdk",
-  version: "0.2.2"};
+  version: "0.3.0"};
 
 // src/circuits/constants.ts
 var PACKAGE_NAME = package_default.name;
@@ -7637,10 +8507,10 @@ var DEPOSIT_COMPUTE_UNIT_LIMIT = 35e4;
 function bytesToHex(bytes) {
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function hexToBytes(hex) {
-  const clean = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+function hexToBytes(hex2) {
+  const clean = hex2.startsWith("0x") || hex2.startsWith("0X") ? hex2.slice(2) : hex2;
   if (clean.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(clean)) {
-    throw new Error(`veilix-sdk: invalid hex string "${hex}"`);
+    throw new Error(`veilix-sdk: invalid hex string "${hex2}"`);
   }
   const out = new Uint8Array(clean.length / 2);
   for (let i = 0; i < out.length; i++) {
@@ -7649,15 +8519,15 @@ function hexToBytes(hex) {
   return out;
 }
 function bigintToBytes32(value) {
-  const hex = BigInt(value).toString(16).padStart(64, "0");
-  if (hex.length > 64) {
+  const hex2 = BigInt(value).toString(16).padStart(64, "0");
+  if (hex2.length > 64) {
     throw new Error("veilix-sdk: value does not fit in 32 bytes");
   }
-  return hexToBytes(hex);
+  return hexToBytes(hex2);
 }
 function bytesToBigint(bytes) {
-  const hex = bytesToHex(bytes);
-  return hex ? BigInt(`0x${hex}`) : 0n;
+  const hex2 = bytesToHex(bytes);
+  return hex2 ? BigInt(`0x${hex2}`) : 0n;
 }
 function toHex32(value) {
   return `0x${BigInt(value).toString(16).padStart(64, "0")}`;
@@ -7775,6 +8645,7 @@ var Utxo = class _Utxo {
 // src/core/note.ts
 var NOTE_PREFIX = "vx2";
 var ENCRYPTED_OUTPUT_VERSION = 1;
+var ENCRYPTED_SWAP_OUTPUT_VERSION = 2;
 var ENCRYPTED_OUTPUT_PLAINTEXT_BYTES = 1 + 8 + 32 + 32;
 var SECRETBOX_NONCE_BYTES = nacl.secretbox.nonceLength;
 function encodeNote(utxo) {
@@ -7807,14 +8678,14 @@ function decodeNote(note) {
     throw new Error("veilix-sdk: invalid note format");
   }
   const [, amountHex, privKeyHex, blindingHex, mint] = parts;
-  const hex = /^[0-9a-f]+$/i;
-  if (!hex.test(amountHex) || !hex.test(privKeyHex) || !hex.test(blindingHex)) {
+  const hex2 = /^[0-9a-f]+$/i;
+  if (!hex2.test(amountHex) || !hex2.test(privKeyHex) || !hex2.test(blindingHex)) {
     throw new Error("veilix-sdk: invalid note format");
   }
-  let mintKey = null;
+  let mintKey2 = null;
   if (mint) {
     try {
-      mintKey = new PublicKey(mint);
+      mintKey2 = new PublicKey(mint);
     } catch {
       throw new Error("veilix-sdk: invalid note mint");
     }
@@ -7823,7 +8694,7 @@ function decodeNote(note) {
     amount: BigInt(`0x${amountHex}`),
     keypair: VeilixKeypair.fromPrivateKey(BigInt(`0x${privKeyHex}`)),
     blinding: BigInt(`0x${blindingHex}`),
-    mint: mintKey
+    mint: mintKey2
   });
 }
 function describeUtxo(utxo) {
@@ -7841,7 +8712,7 @@ function describeUtxo(utxo) {
 function parseSecretNote(note) {
   return describeUtxo(decodeNote(note));
 }
-function encryptNoteOutput(key, utxo) {
+function encryptNoteOutput(key2, utxo) {
   const amount = new Uint8Array(8);
   new DataView(amount.buffer).setBigUint64(0, utxo.amount, true);
   const plaintext = concatBytes([
@@ -7851,21 +8722,38 @@ function encryptNoteOutput(key, utxo) {
     bigintToBytes32(utxo.blinding)
   ]);
   const nonce = nacl.randomBytes(SECRETBOX_NONCE_BYTES);
-  return concatBytes([nonce, nacl.secretbox(plaintext, nonce, key)]);
+  return concatBytes([nonce, nacl.secretbox(plaintext, nonce, key2)]);
+}
+function encryptSwapNoteOutput(key2, keypair, blinding) {
+  const plaintext = concatBytes([
+    Uint8Array.of(ENCRYPTED_SWAP_OUTPUT_VERSION),
+    new Uint8Array(8),
+    bigintToBytes32(keypair.privKey),
+    bigintToBytes32(blinding)
+  ]);
+  const nonce = nacl.randomBytes(SECRETBOX_NONCE_BYTES);
+  return concatBytes([nonce, nacl.secretbox(plaintext, nonce, key2)]);
 }
-function decryptNoteOutput(key, encryptedOutput, mint, index) {
+function decryptNoteOutput(key2, encryptedOutput, mint, index, onchainAmount = null) {
   if (encryptedOutput.length !== SECRETBOX_NONCE_BYTES + nacl.secretbox.overheadLength + ENCRYPTED_OUTPUT_PLAINTEXT_BYTES) {
     return null;
   }
   const opened = nacl.secretbox.open(
     encryptedOutput.subarray(SECRETBOX_NONCE_BYTES),
     encryptedOutput.subarray(0, SECRETBOX_NONCE_BYTES),
-    key
+    key2
   );
-  if (!opened || opened[0] !== ENCRYPTED_OUTPUT_VERSION) {
+  if (!opened) {
+    return null;
+  }
+  let amount;
+  if (opened[0] === ENCRYPTED_OUTPUT_VERSION) {
+    amount = new DataView(opened.buffer, opened.byteOffset + 1, 8).getBigUint64(0, true);
+  } else if (opened[0] === ENCRYPTED_SWAP_OUTPUT_VERSION && onchainAmount !== null) {
+    amount = onchainAmount;
+  } else {
     return null;
   }
-  const amount = new DataView(opened.buffer, opened.byteOffset + 1, 8).getBigUint64(0, true);
   return new Utxo({
     amount,
     keypair: VeilixKeypair.fromPrivateKey(bytesToBigint(opened.subarray(9, 41))),
@@ -16346,6 +17234,7 @@ async function proveTransaction({
   inputs = [],
   outputs = [],
   ext,
+  extDataHashOverride,
   circuit
 }) {
   for (const utxo of [...inputs, ...outputs]) {
@@ -16395,7 +17284,7 @@ async function proveTransaction({
   const input = {
     root: proofRoot.toString(),
     publicAmount: publicAmount.toString(),
-    extDataHash: (await extDataHash(ext)).toString(),
+    extDataHash: (extDataHashOverride ?? await extDataHash(ext)).toString(),
     mint: mintToField(ext.mint).toString(),
     inputNullifier: inputNullifiers.map(String),
     outputCommitment: outputCommitments.map(String),
@@ -16536,8 +17425,8 @@ function generateDepositParams(amount, mint = null) {
   if (value <= 0n) {
     throw new Error("veilix-sdk: deposit amount must be positive");
   }
-  const mintKey = mint && mint !== WRAPPED_SOL_MINT ? new PublicKey(mint) : null;
-  const note = encodeNote(new Utxo({ amount: value, mint: mintKey }));
+  const mintKey2 = mint && mint !== WRAPPED_SOL_MINT ? new PublicKey(mint) : null;
+  const note = encodeNote(new Utxo({ amount: value, mint: mintKey2 }));
   return { note, params: parseSecretNote(note) };
 }
 function to32ByteBuffer(value) {
@@ -16571,8 +17460,8 @@ function toPublicKey(value) {
 }
 function normalizeTreeMint(mint) {
   if (!mint) return null;
-  const key = toPublicKey(mint);
-  return key.equals(NATIVE_MINT) || key.equals(PublicKey.default) ? null : key;
+  const key2 = toPublicKey(mint);
+  return key2.equals(NATIVE_MINT) || key2.equals(PublicKey.default) ? null : key2;
 }
 function getTreePDA(mint) {
   const treeMint = normalizeTreeMint(mint);
@@ -16823,8 +17712,8 @@ async function resolveEncryptKey() {
 }
 async function buildBackupNotesInstruction(sender, notes) {
   const { program } = getConfig();
-  const key = await resolveEncryptKey();
-  return program.methods.backupNotes(notes.map((note) => encryptData(key, note))).accountsPartial({ user: sender }).instruction();
+  const key2 = await resolveEncryptKey();
+  return program.methods.backupNotes(notes.map((note) => encryptData(key2, note))).accountsPartial({ user: sender }).instruction();
 }
 async function isExtendBackupPdaNeeded(walletPubkey, newNotesLength) {
   const account = await fetchNotesAccount(walletPubkey);
@@ -16929,30 +17818,40 @@ async function getEncryptionKey(wallet) {
   }
   return nacl.hash(signature).slice(0, 32);
 }
-function encryptData(key, plaintext) {
+function encryptData(key2, plaintext) {
   const nonce = nacl.randomBytes(24);
-  const box = nacl.secretbox(new TextEncoder().encode(plaintext), nonce, key);
+  const box = nacl.secretbox(new TextEncoder().encode(plaintext), nonce, key2);
   const combined = new Uint8Array(nonce.length + box.length);
   combined.set(nonce);
   combined.set(box, nonce.length);
   return Buffer.from(combined);
 }
-function decryptData(key, combined) {
-  const decrypted = nacl.secretbox.open(combined.slice(24), combined.slice(0, 24), key);
+function decryptData(key2, combined) {
+  const decrypted = nacl.secretbox.open(combined.slice(24), combined.slice(0, 24), key2);
   if (!decrypted) throw new Error("Decryption failed");
   return new TextDecoder().decode(decrypted);
 }
 
 // src/tokenAssets.ts
 var WRAPPED_SOL_MINT2 = "So11111111111111111111111111111111111111112";
+var TOKEN_MINT_TABLES = [MAINNET_TOKEN_MINTS, DEVNET_TOKEN_MINTS];
+function indexerLabelForMint(mint) {
+  if (mint === WRAPPED_SOL_MINT2) return INDEXER_ASSET_LABELS.Solana;
+  for (const table of TOKEN_MINT_TABLES) {
+    for (const symbol of Object.keys(table)) {
+      if (table[symbol] && table[symbol] === mint) return INDEXER_ASSET_LABELS[symbol];
+    }
+  }
+  return void 0;
+}
 function resolveIndexerAsset(indexerAsset) {
-  if (!indexerAsset) return "SOL";
+  if (!indexerAsset) return INDEXER_ASSET_LABELS.Solana;
   if (typeof indexerAsset === "string") {
-    return indexerAsset === WRAPPED_SOL_MINT2 ? "SOL" : indexerAsset;
+    return indexerLabelForMint(indexerAsset) ?? indexerAsset;
   }
-  if (indexerAsset.asset) return indexerAsset.asset;
-  if (indexerAsset.mint && indexerAsset.mint !== WRAPPED_SOL_MINT2) return indexerAsset.mint;
-  return "SOL";
+  if (indexerAsset.asset) return indexerLabelForMint(indexerAsset.asset) ?? indexerAsset.asset;
+  if (indexerAsset.mint) return indexerLabelForMint(indexerAsset.mint) ?? indexerAsset.mint;
+  return INDEXER_ASSET_LABELS.Solana;
 }
 function indexerAssetForMint(mint) {
   return resolveIndexerAsset(mint ?? null);
@@ -16966,8 +17865,8 @@ var COMMITMENTS_PAGE_LIMIT = 8e3;
 var VALIDATE_NULLIFIERS_BATCH = 64;
 async function indexerGet(path, params) {
   const query = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== void 0 && value !== "") query.set(key, value);
+  for (const [key2, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== "") query.set(key2, value);
   }
   const qs = query.toString();
   return httpFetch(`${getIndexerUrl()}${path}${qs ? `?${qs}` : ""}`, {
@@ -17182,7 +18081,7 @@ async function scanOwnedNotes({
   mints,
   includeSpent = false
 } = {}) {
-  const key = requireEncryptKey();
+  const key2 = requireEncryptKey();
   const explicit = mints !== void 0;
   const tokenMints = getTokenMintsForNetwork(getConfig().network);
   const targets = mints ?? [null, tokenMints.Veilix, tokenMints.Bitcoin, tokenMints.Ethereum, tokenMints.USDC].filter(
@@ -17200,7 +18099,13 @@ async function scanOwnedNotes({
     }
     for (const leaf of leaves) {
       if (!leaf.encryptedOutput || leaf.encryptedOutput.length <= 2) continue;
-      const utxo = decryptNoteOutput(key, hexToBytes(leaf.encryptedOutput), treeMint, leaf.index);
+      const utxo = decryptNoteOutput(
+        key2,
+        hexToBytes(leaf.encryptedOutput),
+        treeMint,
+        leaf.index,
+        leaf.amountRaw ? BigInt(leaf.amountRaw) : null
+      );
       if (!utxo || utxo.amount === 0n) continue;
       if (toHex32(utxo.commitment()) !== toHex32(BigInt(leaf.commitment))) continue;
       found.push({ utxo, note: encodeNote(utxo), signature: null });
@@ -17480,6 +18385,364 @@ async function getQuote(params) {
   }
   return data;
 }
+var SWAP_DOMAIN = new TextEncoder().encode("veilix:swap:v1");
+async function swapExtDataHash(ext) {
+  const hash = await sha256(
+    concatBytes([
+      SWAP_DOMAIN,
+      (ext.mintIn ?? PublicKey.default).toBytes(),
+      (ext.mintOut ?? PublicKey.default).toBytes(),
+      ext.relayer.toBytes(),
+      u64le(ext.amountIn),
+      u64le(ext.fee),
+      u64le(ext.minAmountOut),
+      bigintToBytes32(ext.outPubkey),
+      bigintToBytes32(ext.outBlinding),
+      u32le(ext.encryptedOutput1.length),
+      ext.encryptedOutput1,
+      u32le(ext.encryptedOutput2.length),
+      ext.encryptedOutput2,
+      u32le(ext.encryptedNote.length),
+      ext.encryptedNote
+    ])
+  );
+  hash[0] = 0;
+  return bytesToBigint(hash);
+}
+var CPMM_PROGRAM_IDS = {
+  devnet: "DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb",
+  mainnet: "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C"
+};
+var FEE_RATE_DENOMINATOR = 1000000n;
+var SWAP_DISABLED_BIT = 2;
+var key = (data, offset) => new PublicKey(data.subarray(offset, offset + 32));
+var u64 = (data, offset) => new DataView(data.buffer, data.byteOffset + offset, 8).getBigUint64(0, true);
+var ceilDiv = (a, b) => (a + b - 1n) / b;
+var feeOf = (amount, rate) => ceilDiv(amount * rate, FEE_RATE_DENOMINATOR);
+async function quoteCpmm(connection, network, poolAddress, treeMintIn, treeMintOut, amountIn) {
+  const programId = new PublicKey(CPMM_PROGRAM_IDS[network]);
+  const poolInfo = await connection.getAccountInfo(poolAddress, "confirmed");
+  if (!poolInfo || !poolInfo.owner.equals(programId) || poolInfo.data.length < 381) {
+    throw new Error("veilix-sdk: swap pool is not a Raydium CPMM pool");
+  }
+  const data = poolInfo.data;
+  const pool = {
+    ammConfig: key(data, 8),
+    vault0: key(data, 72),
+    vault1: key(data, 104),
+    mint0: key(data, 168),
+    mint1: key(data, 200),
+    status: data[329],
+    protocolFees: [u64(data, 341), u64(data, 349)],
+    fundFees: [u64(data, 357), u64(data, 365)],
+    creatorFeeOn: data.length >= 413 ? data[389] : 0,
+    enableCreatorFee: data.length >= 413 ? data[390] === 1 : false,
+    creatorFees: data.length >= 413 ? [u64(data, 397), u64(data, 405)] : [0n, 0n]
+  };
+  if (pool.status >> SWAP_DISABLED_BIT & 1) {
+    throw new Error("veilix-sdk: swaps are disabled on this pool");
+  }
+  const mintIn = treeMintIn ?? NATIVE_MINT;
+  const mintOut = treeMintOut ?? NATIVE_MINT;
+  let zeroForOne;
+  if (pool.mint0.equals(mintIn) && pool.mint1.equals(mintOut)) zeroForOne = true;
+  else if (pool.mint1.equals(mintIn) && pool.mint0.equals(mintOut)) zeroForOne = false;
+  else throw new Error("veilix-sdk: swap pool does not trade this pair");
+  const [i, o] = zeroForOne ? [0, 1] : [1, 0];
+  const [configInfo, vaultIn, vaultOut] = await connection.getMultipleAccountsInfo(
+    [pool.ammConfig, zeroForOne ? pool.vault0 : pool.vault1, zeroForOne ? pool.vault1 : pool.vault0],
+    "confirmed"
+  );
+  if (!configInfo || !vaultIn || !vaultOut) {
+    throw new Error("veilix-sdk: swap pool accounts are missing");
+  }
+  const tradeFeeRate = u64(configInfo.data, 12);
+  const creatorFeeRate = pool.enableCreatorFee && configInfo.data.length >= 116 ? u64(configInfo.data, 108) : 0n;
+  const reserveIn = u64(vaultIn.data, 64) - pool.protocolFees[i] - pool.fundFees[i] - pool.creatorFees[i];
+  const reserveOut = u64(vaultOut.data, 64) - pool.protocolFees[o] - pool.fundFees[o] - pool.creatorFees[o];
+  if (reserveIn <= 0n || reserveOut <= 0n) {
+    throw new Error("veilix-sdk: swap pool has no liquidity");
+  }
+  const creatorOnInput = pool.creatorFeeOn === 0 || pool.creatorFeeOn === 1 && zeroForOne || pool.creatorFeeOn === 2 && !zeroForOne;
+  let inLessFees = amountIn - feeOf(amountIn, tradeFeeRate);
+  if (creatorOnInput) inLessFees -= feeOf(amountIn, creatorFeeRate);
+  let amountOut = inLessFees * reserveOut / (reserveIn + inLessFees);
+  if (!creatorOnInput) amountOut -= feeOf(amountOut, creatorFeeRate);
+  if (amountOut <= 0n) {
+    throw new Error("veilix-sdk: swap amount is too small for this pool");
+  }
+  const spotOut = Number(inLessFees) * (Number(reserveOut) / Number(reserveIn));
+  const priceImpact = spotOut > 0 ? Math.max(0, 1 - Number(amountOut) / spotOut) : 1;
+  return { amountOut, priceImpact };
+}
+
+// src/swap/execute.ts
+var SWAP_MAX_WAIT_MS = 18e4;
+var DEFAULT_SLIPPAGE_BPS = 100;
+var MAX_SLIPPAGE_BPS = 5e3;
+var MAX_PRICE_IMPACT = 0.1;
+var hex = (bytes) => `0x${bytesToHex(bytes)}`;
+var mintKey = (mint) => mint?.toBase58() ?? null;
+async function fetchRelayerQuote(relayerUrl, mintIn, mintOut, amountIn) {
+  const params = new URLSearchParams({ amountIn: amountIn.toString() });
+  if (mintIn) params.set("mintIn", mintIn.toBase58());
+  if (mintOut) params.set("mintOut", mintOut.toBase58());
+  const base = relayerUrl.replace(/\/$/, "");
+  const res = await httpFetch(`${base}/v1/swapQuote?${params}`, {
+    headers: { Accept: "application/json" }
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(body.error || `Swap quote failed (${res.status})`);
+  }
+  return { ...body, relayerUrl: base };
+}
+function swapCandidates(relayers, relayerUrl) {
+  if (relayerUrl) {
+    const wanted = relayerUrl.replace(/\/$/, "");
+    const match = relayers.find((r) => r.url.replace(/\/$/, "") === wanted);
+    if (!match) throw new Error(`veilix-sdk: relayer ${relayerUrl} is not available`);
+    return [match];
+  }
+  if (!relayers.length) throw new Error("veilix-sdk: no relayer available");
+  const first = getRandomRelayer(relayers);
+  return [first, ...relayers.filter((r) => r !== first)];
+}
+async function getSwapQuote(params) {
+  const { relayers } = getConfig();
+  const mintIn = normalizeTreeMint(params.mintIn);
+  const mintOut = normalizeTreeMint(params.mintOut);
+  if (mintKey(mintIn) === mintKey(mintOut)) {
+    throw new Error("veilix-sdk: swap needs two different assets");
+  }
+  const amountIn = BigInt(params.amountIn);
+  if (amountIn <= 0n) throw new Error("veilix-sdk: swap amount must be positive");
+  const { connection, network } = getConfig();
+  const platformWallets = await fetchPlatformFeeWallets();
+  let lastError = null;
+  for (const relayer of swapCandidates(relayers, params.relayerUrl)) {
+    try {
+      const quote = await fetchRelayerQuote(relayer.url, mintIn, mintOut, amountIn);
+      if (quote.relayer !== relayer.value) {
+        throw new Error("Relayer quoted for a different reward account");
+      }
+      const { fee } = computeWithdrawFee(amountIn, relayer.fee, platformWallets);
+      if (fee >= amountIn) throw new Error("Amount is too small to cover the fees");
+      if (BigInt(quote.fee) !== fee) throw new Error("Relayer quoted a different fee");
+      if (quote.dexProgram !== CPMM_PROGRAM_IDS[network]) {
+        throw new Error("Relayer routes through an unsupported DEX");
+      }
+      const own = await quoteCpmm(
+        connection,
+        network,
+        new PublicKey(quote.pool),
+        mintIn,
+        mintOut,
+        amountIn - fee
+      );
+      if (own.priceImpact > MAX_PRICE_IMPACT) {
+        throw new Error(
+          `Price impact ${(own.priceImpact * 100).toFixed(1)}% is too high for this pool; swap less`
+        );
+      }
+      return {
+        quote: {
+          ...quote,
+          swapIn: (amountIn - fee).toString(),
+          amountOut: own.amountOut.toString(),
+          priceImpact: own.priceImpact
+        },
+        relayer
+      };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  const reason = lastError instanceof Error ? lastError.message : "no relayer routes this pair";
+  throw new Error(`veilix-sdk: no swap route for this pair (${reason})`);
+}
+async function buildSwapPayload(params, options = {}) {
+  const { encryptKey } = getConfig();
+  const utxo = decodeNote(params.note);
+  const mintIn = utxo.mint;
+  const mintOut = normalizeTreeMint(params.mintOut ?? null);
+  const slippageBps = params.slippageBps ?? DEFAULT_SLIPPAGE_BPS;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > MAX_SLIPPAGE_BPS) {
+    throw new Error(`veilix-sdk: slippageBps must be an integer between 0 and ${MAX_SLIPPAGE_BPS}`);
+  }
+  const { index } = await locateNote(utxo);
+  if (index === null) {
+    throw new Error("Note is not in the Veilix pool yet (deposit not confirmed or not indexed)");
+  }
+  utxo.index = index;
+  if ((await validateNullifier(toHex32(utxo.nullifier()))).exists) {
+    throw new Error("This note has already been spent");
+  }
+  const amountIn = params.amount === void 0 ? utxo.amount : BigInt(params.amount);
+  if (amountIn <= 0n || amountIn > utxo.amount) {
+    throw new Error(`Swap amount must be between 1 and ${utxo.amount}`);
+  }
+  const { quote, relayer } = await getSwapQuote({
+    mintIn,
+    mintOut,
+    amountIn,
+    relayerUrl: params.relayerUrl
+  });
+  const fee = BigInt(quote.fee);
+  const minAmountOut = BigInt(quote.amountOut) * BigInt(1e4 - slippageBps) / 10000n;
+  if (minAmountOut <= 0n) {
+    throw new Error("Swap amount is too small for this pool");
+  }
+  let tree = options.tree;
+  if (!tree || tree.elements.length <= index) {
+    tree = await fetchAssetTree(mintKey(mintIn));
+  }
+  if (tree.elements.length <= index) {
+    throw new Error("The indexer has not synced this note yet, retry shortly");
+  }
+  const change = utxo.amount - amountIn;
+  const changeUtxo = change > 0n ? new Utxo({ amount: change, mint: mintIn }) : null;
+  const encryptedOutput1 = changeUtxo && encryptKey ? encryptNoteOutput(encryptKey, changeUtxo) : new Uint8Array();
+  const encryptedOutput2 = new Uint8Array();
+  const outKeypair = VeilixKeypair.random();
+  const outBlinding = randomFieldElement();
+  const encryptedNote = encryptKey ? encryptSwapNoteOutput(encryptKey, outKeypair, outBlinding) : new Uint8Array();
+  const relayerKey = new PublicKey(relayer.value);
+  const hash = await swapExtDataHash({
+    mintIn,
+    mintOut,
+    relayer: relayerKey,
+    amountIn,
+    fee,
+    minAmountOut,
+    outPubkey: outKeypair.pubKey,
+    outBlinding,
+    encryptedOutput1,
+    encryptedOutput2,
+    encryptedNote
+  });
+  const proved = await withCircuitArtifacts(
+    options.circuitArtifacts,
+    (artifacts) => proveTransaction({
+      tree,
+      inputs: [utxo],
+      outputs: changeUtxo ? [changeUtxo] : [],
+      ext: {
+        mint: mintIn,
+        recipient: PublicKey.default,
+        relayer: relayerKey,
+        extAmount: -amountIn,
+        fee,
+        encryptedOutput1,
+        encryptedOutput2
+      },
+      extDataHashOverride: hash,
+      circuit: artifacts
+    })
+  );
+  const { proof } = proved;
+  const payload = {
+    proof: hex(proof.proof),
+    root: hex(proof.root),
+    inputNullifiers: [hex(proof.inputNullifiers[0]), hex(proof.inputNullifiers[1])],
+    outputCommitments: [hex(proof.outputCommitments[0]), hex(proof.outputCommitments[1])],
+    ...mintIn ? { mintIn: mintIn.toBase58() } : {},
+    ...mintOut ? { mintOut: mintOut.toBase58() } : {},
+    amountIn: amountIn.toString(),
+    fee: fee.toString(),
+    minAmountOut: minAmountOut.toString(),
+    outPubkey: hex(bigintToBytes32(outKeypair.pubKey)),
+    outBlinding: hex(bigintToBytes32(outBlinding)),
+    relayer: relayerKey.toBase58(),
+    encryptedOutput1: hex(encryptedOutput1),
+    encryptedOutput2: hex(encryptedOutput2),
+    encryptedNote: hex(encryptedNote)
+  };
+  return {
+    payload,
+    relayerUrl: quote.relayerUrl,
+    quote,
+    amountIn,
+    fee,
+    minAmountOut,
+    changeNote: changeUtxo ? encodeNote(changeUtxo) : null,
+    output: {
+      mint: mintKey(mintOut),
+      privKey: outKeypair.privKey.toString(),
+      blinding: outBlinding.toString()
+    },
+    nullifiers: [...payload.inputNullifiers]
+  };
+}
+async function pollSwapJob(relayerUrl, jobId, maxWaitMs) {
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    const res = await httpFetch(`${relayerUrl}/v1/jobs/${encodeURIComponent(jobId)}`, {
+      headers: { Accept: "application/json" }
+    });
+    const job = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(job.error || "Failed to poll relayer job");
+    if (job.status === "CONFIRMED" || job.status === "FAILED") return job;
+    await new Promise((resolve) => setTimeout(resolve, 3e3));
+  }
+  throw new Error("Swap timed out");
+}
+function swapOutputNote(output, result) {
+  const utxo = new Utxo({
+    amount: BigInt(result.amountOut),
+    keypair: VeilixKeypair.fromPrivateKey(output.privKey),
+    blinding: BigInt(output.blinding),
+    mint: output.mint ? new PublicKey(output.mint) : null,
+    index: result.outputIndex
+  });
+  if (toHex32(utxo.commitment()) !== toHex32(BigInt(result.outputCommitment))) {
+    throw new Error("veilix-sdk: swapped note does not match the on-chain commitment");
+  }
+  return encodeNote(utxo);
+}
+async function submitSwapPayload(bundle) {
+  const res = await httpFetch(`${bundle.relayerUrl}/v1/veilixSwap`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(bundle.payload)
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.id) {
+    throw new Error(body.error || "Swap submission failed");
+  }
+  const job = await pollSwapJob(bundle.relayerUrl, body.id, SWAP_MAX_WAIT_MS);
+  const base = {
+    changeNote: bundle.changeNote,
+    amountIn: bundle.amountIn.toString(),
+    fee: bundle.fee.toString(),
+    minAmountOut: bundle.minAmountOut.toString()
+  };
+  if (job.status === "FAILED") {
+    return {
+      ...base,
+      txHash: job.txHash ?? "",
+      status: "failed",
+      error: job.failedReason || "Swap failed",
+      // A failed swap spends nothing: the original note is still valid.
+      outputNote: null,
+      changeNote: null,
+      amountOut: null
+    };
+  }
+  if (!job.txHash || !job.swapResult) {
+    throw new Error("Swap confirmed but the relayer did not report the swapped note");
+  }
+  return {
+    ...base,
+    txHash: job.txHash,
+    status: "success",
+    outputNote: swapOutputNote(bundle.output, job.swapResult),
+    amountOut: job.swapResult.amountOut
+  };
+}
+async function executeSwap(params) {
+  return submitSwapPayload(await buildSwapPayload(params));
+}
 
 // src/withdraw/assets.ts
 var TOKEN_UNITS = {
@@ -17920,6 +19183,26 @@ var VeilixSDK = class _VeilixSDK {
   submitWithdrawPayload(bundle) {
     return this.runAsync(() => submitWithdrawPayload(bundle));
   }
+  // ── Private swap ─────────────────────────────────────────────────────
+  /** Fee and expected output of swapping `amountIn` of `mintIn` into `mintOut`. */
+  getSwapQuote(params) {
+    return this.runAsync(() => getSwapQuote(params));
+  }
+  /**
+   * Swap a note of asset A into a new shielded note of asset B (`mintOut`, `null` for
+   * SOL) through a relayer and an allowlisted DEX. Funds never leave the pool
+   * unshielded. Returns the asset-B note and any asset-A change note.
+   */
+  swap(params) {
+    return this.runAsync(() => executeSwap(params));
+  }
+  /** Prove a swap without submitting it (see {@link submitSwapPayload}). */
+  buildSwapPayload(params, options) {
+    return this.runAsync(() => buildSwapPayload(params, options));
+  }
+  submitSwapPayload(bundle) {
+    return this.runAsync(() => submitSwapPayload(bundle));
+  }
   /**
    * Private transfer: deposit one note per item, then withdraw each note in full
    * to its recipient through the indexer submission queue.
@@ -18031,15 +19314,15 @@ var VeilixSDK = class _VeilixSDK {
    * Accepts a frontend wallet adapter (`signMessage`) or a backend {@link Keypair}.
    */
   async getEncryptionKey(wallet) {
-    const key = await getEncryptionKey(wallet);
-    this.config.encryptKey = key;
-    return key;
+    const key2 = await getEncryptionKey(wallet);
+    this.config.encryptKey = key2;
+    return key2;
   }
-  encryptData(key, plaintext) {
-    return encryptData(key, plaintext);
+  encryptData(key2, plaintext) {
+    return encryptData(key2, plaintext);
   }
-  decryptData(key, combined) {
-    return decryptData(key, combined);
+  decryptData(key2, combined) {
+    return decryptData(key2, combined);
   }
   // ── Utilities ────────────────────────────────────────────────────────
   parseAmountToBaseUnits(amount, decimals) {