@unlink-xyz/react 0.1.0 → 0.1.3-canary.3ed2902

package/dist/index.js

@@ -5292,6 +5292,12 @@ var ReconcileError = class extends CoreError {
     this.status = status;
   }
 };
+var AdapterError = class extends CoreError {
+  constructor(message) {
+    super(message);
+    this.name = "AdapterError";
+  }
+};
 init_process();
 init_buffer();
 var RESERVED_PREFIXES = [
@@ -9444,7 +9450,12 @@ var VALID_STATUSES = [
   "failed",
   "dead"
 ];
-var VALID_KINDS = ["deposit", "transfer", "withdraw"];
+var VALID_KINDS = [
+  "deposit",
+  "transfer",
+  "withdraw",
+  "adapter"
+];
 function assertStatus(status) {
   if (!VALID_STATUSES.includes(status)) {
     throw new CoreError(`invalid job status: ${status}`);
@@ -9524,6 +9535,12 @@ function validateDepositRecord(job) {
     }
   }
 }
+function validateAdapterRecord(job) {
+  ensureAddress("adapter address", job.adapterAddress);
+  if (!job.adapterCalldata) {
+    throw new CoreError("adapterCalldata is required for adapter record");
+  }
+}
 function validateJob(job) {
   if (!job.relayId) {
     throw new CoreError("relayId is required");
@@ -9543,6 +9560,9 @@ function validateJob(job) {
     validateDepositRecord(job);
   } else {
     validatePoolTransactionRecord(job);
+    if (job.kind === "adapter") {
+      validateAdapterRecord(job);
+    }
   }
 }
 function buildJobKey(relayId) {
@@ -10047,6 +10067,9 @@ function randomBigint(bytes2 = 32) {
 function randomHex(bytes2) {
   return `0x${randomBigint(bytes2).toString(16).padStart(bytes2 * 2, "0")}`;
 }
+function generateRelayId(prefix) {
+  return globalThis.crypto?.randomUUID?.() ?? `${prefix}-${randomHex(16).slice(2)}`;
+}
 function normalizeAddress(value) {
   return ensureAddress("address", value);
 }
@@ -36037,9 +36060,6 @@ function buildDepositCalldata(depositor, processedNotes) {
     }))
   ]);
 }
-function generateRelayId(prefix) {
-  return globalThis.crypto?.randomUUID?.() ?? `${prefix}-${Date.now().toString(16)}`;
-}
 async function deposit(store, req) {
   if (!req.notes?.length) {
     throw new ValidationError("At least one note is required for deposit");
@@ -53692,6 +53712,28 @@ function computeBoundParamsHash(chainId, poolAddress, adapterDataHash = 0n) {
   );
   return parseHexToBigInt(keccak256(encoded)) % SNARK_SCALAR_FIELD;
 }
+function computeAdapterDataHash(params) {
+  const coder = AbiCoder.defaultAbiCoder();
+  const encoded = coder.encode(
+    [
+      "tuple(address to, bytes data, uint256 value)[]",
+      "tuple(uint256 npk, uint256 random, address token, uint256 minAmount)[]",
+      "address[]",
+      "uint256",
+      "uint256",
+      "uint256"
+    ],
+    [
+      params.calls,
+      params.reshields,
+      params.inputTokens,
+      params.nonce,
+      params.deadline,
+      BigInt(params.chainId)
+    ]
+  );
+  return parseHexToBigInt(keccak256(encoded)) % SNARK_SCALAR_FIELD;
+}
 async function buildSingleTransactionProof(store, account, signer, chainId, poolAddress, tx, trees, baseIndex, opts) {
   if (!tx.inputs?.length)
     throw new ValidationError("at least one input note is required");
@@ -53873,7 +53915,7 @@ async function transact(store, req, opts) {
       ciphertexts: r2.ciphertexts
     }))
   ]);
-  const relayId = globalThis.crypto?.randomUUID?.() ?? `tx-${Date.now().toString(16)}`;
+  const relayId = generateRelayId("tx");
   const hasAnyWithdrawal = results.some((r2) => r2.withdrawal.amount > 0n);
   const historyKind = hasAnyWithdrawal ? "Withdraw" : "Send";
   const deltasByToken = /* @__PURE__ */ new Map();
@@ -53960,11 +54002,13 @@ async function transact(store, req, opts) {
       throw new CoreError("broadcaster relay timed out");
     }
   }
-  await store.putJob({
-    ...job,
-    status: "broadcasting",
-    txHash
-  });
+  if (opts.persistJob !== false) {
+    await store.putJob({
+      ...job,
+      status: "broadcasting",
+      txHash
+    });
+  }
   const transactionResults = results.map((r2) => ({
     proof: r2.proof,
     witnesses: r2.witnesses,
@@ -53979,7 +54023,7 @@ async function transact(store, req, opts) {
 }
 async function syncTransact(store, relayId, opts) {
   const record = await store.getJob(relayId);
-  if (!record || record.kind !== "transfer" && record.kind !== "withdraw")
+  if (!record || record.kind !== "transfer" && record.kind !== "withdraw" && record.kind !== "adapter")
     throw new CoreError(`unknown pool transaction relay ${relayId}`);
   const job = record;
   const serviceConfig = createServiceConfig(opts.gatewayUrl);
@@ -54083,6 +54127,70 @@ async function syncTransact(store, relayId, opts) {
 }
 init_process();
 init_buffer();
+var ADAPTER_EXECUTE_ABI = [
+  "function execute(bytes _transactData, (address to, bytes data, uint256 value)[] _calls, (uint256 npk, uint256 random, address token, uint256 minAmount)[] _reshields, address[] _inputTokens, uint256 _nonce, uint256 _deadline)"
+];
+var adapterInterface = new Interface(ADAPTER_EXECUTE_ABI);
+var approveInterface = new Interface([
+  "function approve(address spender, uint256 amount)"
+]);
+var HEX_DATA_REGEX = /^0x[0-9a-fA-F]*$/;
+function ensureNonNegative(label, value) {
+  if (value < 0n) {
+    throw new AdapterError(`${label} must be non-negative`);
+  }
+  return value;
+}
+function ensureHexData(label, value) {
+  if (typeof value !== "string" || !HEX_DATA_REGEX.test(value) || value.length % 2 !== 0) {
+    throw new AdapterError(`${label} must be 0x-prefixed even-length hex data`);
+  }
+  return value;
+}
+function normalizeCall(call, index) {
+  const to = ensureAddress(`calls[${index}].to`, call.to);
+  const data = ensureHexData(`calls[${index}].data`, call.data);
+  const value = ensureNonNegative(`calls[${index}].value`, call.value);
+  return { to, data, value };
+}
+function normalizeReshield(reshield, index) {
+  const token = ensureAddress(`reshields[${index}].token`, reshield.token);
+  const npk = ensureNonNegative(`reshields[${index}].npk`, reshield.npk);
+  const random = ensureNonNegative(
+    `reshields[${index}].random`,
+    reshield.random
+  );
+  const minAmount = ensureNonNegative(
+    `reshields[${index}].minAmount`,
+    reshield.minAmount
+  );
+  return { npk, random, token, minAmount };
+}
+function encodeAdapterExecute(params) {
+  const transactCalldata = ensureHexData(
+    "transactCalldata",
+    params.transactCalldata
+  );
+  const calls = params.calls.map((call, i) => normalizeCall(call, i));
+  const reshields = params.reshields.map(
+    (reshield, i) => normalizeReshield(reshield, i)
+  );
+  const inputTokens = params.inputTokens.map(
+    (token, i) => ensureAddress(`inputTokens[${i}]`, token)
+  );
+  const nonce = ensureNonNegative("nonce", params.nonce);
+  const deadline = ensureNonNegative("deadline", params.deadline);
+  return adapterInterface.encodeFunctionData("execute", [
+    transactCalldata,
+    calls,
+    reshields,
+    inputTokens,
+    nonce,
+    deadline
+  ]);
+}
+init_process();
+init_buffer();
 init_process();
 init_buffer();
 var MAX_CIRCUIT_INPUTS = Math.max(
@@ -55447,6 +55555,229 @@ function createSeedService(deps) {
 }
 init_process();
 init_buffer();
+var DEFAULT_DEADLINE_WINDOW_SECONDS = 600n;
+var HEX_DATA_REGEX2 = /^0x[0-9a-fA-F]*$/;
+function ensureHexData2(label, value) {
+  if (typeof value !== "string" || !HEX_DATA_REGEX2.test(value) || value.length % 2 !== 0) {
+    throw new AdapterError(`${label} must be 0x-prefixed even-length hex data`);
+  }
+  return value;
+}
+function normalizeCall2(call, index) {
+  const to = ensureAddress(`calls[${index}].to`, call.to);
+  const data = ensureHexData2(`calls[${index}].data`, call.data);
+  if (call.value < 0n) {
+    throw new AdapterError(`calls[${index}].value must be non-negative`);
+  }
+  return {
+    to,
+    data,
+    value: call.value
+  };
+}
+function normalizeInputSpec(input, index) {
+  const token = ensureAddress(`inputs[${index}].token`, input.token);
+  if (input.amount <= 0n) {
+    throw new AdapterError(`inputs[${index}].amount must be greater than zero`);
+  }
+  return {
+    token,
+    amount: input.amount
+  };
+}
+function normalizeReshieldSpec(reshield, index) {
+  const token = ensureAddress(`reshields[${index}].token`, reshield.token);
+  if (reshield.minAmount < 0n) {
+    throw new AdapterError(
+      `reshields[${index}].minAmount must be non-negative`
+    );
+  }
+  return {
+    token,
+    minAmount: reshield.minAmount
+  };
+}
+function randomFieldElement(randomBigintFn) {
+  const value = randomBigintFn() % SNARK_SCALAR_FIELD;
+  return value < 0n ? value + SNARK_SCALAR_FIELD : value;
+}
+function createAdapterService(deps) {
+  const planWithdrawalsImpl = deps.planWithdrawalsFn ?? planWithdrawals;
+  const transactImpl = deps.transactFn ?? transact;
+  const randomBigintImpl = deps.randomBigintFn ?? randomBigint;
+  const nowImpl = deps.nowFn ?? Date.now;
+  return {
+    async execute(params, opts, overrides) {
+      ensureChainId(params.chainId);
+      const poolAddress = ensureAddress("poolAddress", params.poolAddress);
+      const adapterAddress = ensureAddress(
+        "adapterAddress",
+        params.adapterAddress
+      );
+      if (!params.inputs.length) {
+        throw new AdapterError("at least one input token is required");
+      }
+      if (!params.calls.length) {
+        throw new AdapterError("at least one adapter call is required");
+      }
+      if (!params.reshields.length) {
+        throw new AdapterError("at least one reshield output is required");
+      }
+      const inputs = params.inputs.map(
+        (input, i) => normalizeInputSpec(input, i)
+      );
+      const seenTokens = /* @__PURE__ */ new Set();
+      for (const input of inputs) {
+        const lower = input.token.toLowerCase();
+        if (seenTokens.has(lower)) {
+          throw new AdapterError(
+            `duplicate input token ${input.token}; combine amounts per token instead`
+          );
+        }
+        seenTokens.add(lower);
+      }
+      const calls = params.calls.map((call, i) => normalizeCall2(call, i));
+      const reshieldSpecs = params.reshields.map(
+        (reshield, i) => normalizeReshieldSpec(reshield, i)
+      );
+      const account = overrides?.account ?? await deps.requireActiveAccount();
+      const signer = overrides?.signer ?? deps.requireSigner(account);
+      const nowSeconds = BigInt(Math.floor(nowImpl() / 1e3));
+      const deadline = params.deadline ?? nowSeconds + DEFAULT_DEADLINE_WINDOW_SECONDS;
+      if (deadline <= nowSeconds) {
+        throw new AdapterError("deadline must be in the future");
+      }
+      const executionCalls = calls;
+      const reshields = reshieldSpecs.map(
+        (reshield) => {
+          const random = randomFieldElement(randomBigintImpl);
+          const npk = poseidon([account.masterPublicKey, random]);
+          return {
+            npk,
+            random,
+            token: reshield.token,
+            minAmount: reshield.minAmount
+          };
+        }
+      );
+      const inputTokens = inputs.map((input) => input.token);
+      const nonce = randomFieldElement(randomBigintImpl);
+      const adapterDataHash = computeAdapterDataHash({
+        calls: executionCalls,
+        reshields,
+        inputTokens,
+        nonce,
+        deadline,
+        chainId: params.chainId
+      });
+      const notes = await deps.stateStore.listNotes({
+        chainId: params.chainId,
+        mpk: formatUint256(account.masterPublicKey),
+        includeSpent: false
+      });
+      const withdrawalPlans = planWithdrawalsImpl(
+        notes,
+        inputs.map((input) => ({
+          token: input.token,
+          amount: input.amount,
+          recipient: adapterAddress
+        })),
+        account.masterPublicKey,
+        account.viewingKeyPair.pubkey
+      );
+      const transactResult = await transactImpl(
+        deps.stateStore,
+        {
+          account,
+          signer,
+          chainId: params.chainId,
+          poolAddress,
+          transactions: withdrawalPlans.map((plan) => ({
+            token: plan.token,
+            inputs: plan.inputs.map((note) => ({ index: note.index })),
+            outputs: plan.outputNotes,
+            withdrawal: plan.withdrawal,
+            adapterDataHash
+          }))
+        },
+        {
+          ...deps.txOpts,
+          skipBroadcast: true,
+          persistJob: false
+        }
+      );
+      const adapterCalldata = encodeAdapterExecute({
+        transactCalldata: transactResult.calldata,
+        calls: executionCalls,
+        reshields,
+        inputTokens,
+        nonce,
+        deadline
+      });
+      if (opts?.skipBroadcast) {
+        return {
+          relayId: transactResult.relayId,
+          adapterCalldata,
+          transactCalldata: transactResult.calldata,
+          transactResult,
+          reshields
+        };
+      }
+      const relayId = generateRelayId("adapter");
+      const submission = await deps.broadcasterClient.submitRelay({
+        clientTxId: relayId,
+        chainId: params.chainId,
+        payload: {
+          kind: "call_data",
+          to: adapterAddress,
+          data: adapterCalldata
+        }
+      });
+      if (!submission.accepted) {
+        throw new AdapterError(submission.message ?? "broadcaster rejected");
+      }
+      await deps.stateStore.putJob({
+        relayId,
+        kind: "adapter",
+        chainId: params.chainId,
+        mpk: formatUint256(account.masterPublicKey),
+        status: "broadcasting",
+        txHash: null,
+        createdAt: nowImpl(),
+        timeoutMs: DEFAULT_JOB_TIMEOUT_MS,
+        poolAddress,
+        calldata: transactResult.calldata,
+        transactions: withdrawalPlans.map((plan, i) => ({
+          token: plan.token,
+          nullifiers: transactResult.transactions[i]?.nullifiers ?? [],
+          predictedCommitments: (transactResult.transactions[i]?.predictedCommitments ?? []).map((hex2) => ({ hex: hex2 })),
+          withdrawal: {
+            amount: plan.withdrawal.amount.toString(),
+            recipient: adapterAddress
+          }
+        })),
+        adapterAddress,
+        adapterCalldata,
+        historyPreview: {
+          kind: "Withdraw",
+          amounts: inputs.map((input) => ({
+            token: input.token,
+            delta: (-input.amount).toString()
+          }))
+        }
+      });
+      return {
+        relayId,
+        adapterCalldata,
+        transactCalldata: transactResult.calldata,
+        transactResult,
+        reshields
+      };
+    }
+  };
+}
+init_process();
+init_buffer();
 var BIP44_ETH_PREFIX = "m/44'/60'/0'/0";
 var ERC20_BALANCE_OF = "function balanceOf(address) view returns (uint256)";
 function createBurnerService(deps) {
@@ -55803,6 +56134,13 @@ function createWalletSDK(deps, options) {
       spendingKeyPair.pubkey
     );
   }
+  const adapterService = createAdapterService({
+    stateStore,
+    txOpts,
+    broadcasterClient,
+    requireActiveAccount,
+    requireSigner
+  });
   if (configuredChainId) {
     scheduler.start();
   }
@@ -55903,10 +56241,13 @@ function createWalletSDK(deps, options) {
         return getBurnerService().sweepToPool(index, params);
       }
     },
+    adapter: {
+      execute: async (params, opts, overrides) => adapterService.execute(params, opts, overrides)
+    },
     balances: {
-      async list(chainId) {
+      async list(chainId, overrides) {
         ensureChainId(chainId);
-        const account = await requireActiveAccount();
+        const account = overrides?.account ?? await requireActiveAccount();
         const notes = await stateStore.listNotes({
           chainId,
           mpk: formatUint256(account.masterPublicKey),
@@ -55914,15 +56255,15 @@ function createWalletSDK(deps, options) {
         });
         return computeBalances(notes);
       },
-      async get(chainId, token) {
-        const balances = await this.list(chainId);
+      async get(chainId, token, overrides) {
+        const balances = await this.list(chainId, overrides);
         return balances[token.toLowerCase()] ?? 0n;
       }
     },
     deposit: {
       async request(params) {
         ensureChainId(params.chainId);
-        const account = await requireActiveAccount();
+        const account = params.account ?? await requireActiveAccount();
         const notes = params.deposits.map((d2) => {
           const randomBytes5 = rng(32);
           const random = BigInt(
@@ -55957,9 +56298,9 @@ function createWalletSDK(deps, options) {
       }
     },
     history: {
-      async list(chainId, options2) {
+      async list(chainId, options2, overrides) {
         ensureChainId(chainId);
-        const account = await requireActiveAccount();
+        const account = overrides?.account ?? await requireActiveAccount();
         return historyService.getHistory({
           chainId,
           mpk: formatUint256(account.masterPublicKey),
@@ -55984,9 +56325,9 @@ function createWalletSDK(deps, options) {
         });
         await historyService.rebuildHistory({ chainId: note.chainId, mpk });
       },
-      async list(chainId) {
+      async list(chainId, overrides) {
         ensureChainId(chainId);
-        const account = await requireActiveAccount();
+        const account = overrides?.account ?? await requireActiveAccount();
         return stateStore.listNotes({
           chainId,
           mpk: formatUint256(account.masterPublicKey),
@@ -56259,7 +56600,8 @@ var UnlinkWallet = class _UnlinkWallet {
       chainId: this.chainId,
       poolAddress: this.poolAddress,
       depositor: params.depositor,
-      deposits: params.deposits
+      deposits: params.deposits,
+      account: params.account
     });
   }
   /** Wait for a deposit to be confirmed on-chain. */
@@ -56270,57 +56612,71 @@ var UnlinkWallet = class _UnlinkWallet {
    * Execute a private transfer (1 or more recipients).
    * Handles note selection, circuit selection, and proof generation automatically.
    */
-  async transfer(params) {
-    return this.sdk.transfer.send({
-      chainId: this.chainId,
-      poolAddress: this.poolAddress,
-      transfers: params.transfers
-    });
+  async transfer(params, overrides) {
+    return this.sdk.transfer.send(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        transfers: params.transfers
+      },
+      overrides
+    );
   }
   /**
    * Get a transfer plan without executing (for preview/confirmation UIs).
    */
-  async planTransfer(params) {
-    return this.sdk.transfer.plan({
-      chainId: this.chainId,
-      poolAddress: this.poolAddress,
-      transfers: params.transfers
-    });
+  async planTransfer(params, account) {
+    return this.sdk.transfer.plan(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        transfers: params.transfers
+      },
+      account
+    );
   }
   /** Execute a pre-built transfer plan. */
-  async executeTransfer(plans) {
-    return this.sdk.transfer.execute(plans, {
-      chainId: this.chainId,
-      poolAddress: this.poolAddress
-    });
+  async executeTransfer(plans, overrides) {
+    return this.sdk.transfer.execute(
+      plans,
+      { chainId: this.chainId, poolAddress: this.poolAddress },
+      overrides
+    );
   }
   /**
    * Execute a withdrawal (1 or more recipients).
    * Handles note selection, circuit selection, and proof generation automatically.
    */
-  async withdraw(params) {
-    return this.sdk.withdraw.send({
-      chainId: this.chainId,
-      poolAddress: this.poolAddress,
-      withdrawals: params.withdrawals
-    });
+  async withdraw(params, overrides) {
+    return this.sdk.withdraw.send(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        withdrawals: params.withdrawals
+      },
+      overrides
+    );
   }
   /**
    * Get a withdrawal plan without executing (for preview/confirmation UIs).
    */
-  async planWithdraw(params) {
-    return this.sdk.withdraw.plan({
-      chainId: this.chainId,
-      poolAddress: this.poolAddress,
-      withdrawals: params.withdrawals
-    });
+  async planWithdraw(params, account) {
+    return this.sdk.withdraw.plan(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        withdrawals: params.withdrawals
+      },
+      account
+    );
   }
   /** Execute a pre-built withdrawal plan. */
-  async executeWithdraw(plans) {
-    return this.sdk.withdraw.execute(plans, {
-      chainId: this.chainId,
-      poolAddress: this.poolAddress
-    });
+  async executeWithdraw(plans, overrides) {
+    return this.sdk.withdraw.execute(
+      plans,
+      { chainId: this.chainId, poolAddress: this.poolAddress },
+      overrides
+    );
   }
   /** Wait for a transfer or withdrawal to be confirmed on-chain. */
   async confirmTransaction(relayId) {
@@ -56331,28 +56687,28 @@ var UnlinkWallet = class _UnlinkWallet {
    * Get balance for a specific token (defaults to all tokens if no token specified).
    * @param token Token address. If omitted, returns balance for all tokens via getBalances().
    */
-  async getBalance(token) {
-    return this.sdk.balances.get(this.chainId, token);
+  async getBalance(token, overrides) {
+    return this.sdk.balances.get(this.chainId, token, overrides);
   }
   /** Get balances for all tokens. */
-  async getBalances() {
-    return this.sdk.balances.list(this.chainId);
+  async getBalances(overrides) {
+    return this.sdk.balances.list(this.chainId, overrides);
   }
   /** Get transaction history. */
-  async getHistory(options) {
-    return this.sdk.history.list(this.chainId, options);
+  async getHistory(options, overrides) {
+    return this.sdk.history.list(this.chainId, options, overrides);
   }
-  /** Get UTXO notes for the active account. */
-  async getNotes() {
-    return this.sdk.notes.list(this.chainId);
+  /** Get UTXO notes for the active account (or override account). */
+  async getNotes(overrides) {
+    return this.sdk.notes.list(this.chainId, overrides);
   }
   // ===== Sync =====
   /**
    * Sync notes from the blockchain.
    * Automatically resolves the active account (no need to pass it).
    */
-  async sync(options) {
-    const account = await this.requireActiveAccount();
+  async sync(options, overrides) {
+    const account = overrides?.account ?? await this.requireActiveAccount();
     return this.sdk.sync.syncChain(this.chainId, account, options);
   }
   /** Start auto-sync at the given interval (default: 5000ms). */
@@ -56429,6 +56785,31 @@ var UnlinkWallet = class _UnlinkWallet {
       return this.sdk.burner.getBalance(address);
     }
   };
+  // ===== Adapter =====
+  /**
+   * Private DeFi adapter operations.
+   * chainId/poolAddress are injected automatically.
+   */
+  adapter = {
+    /**
+     * Execute an atomic unshield -> call(s) -> reshield flow through an adapter.
+     */
+    execute: (params, opts, overrides) => {
+      return this.sdk.adapter.execute(
+        {
+          chainId: this.chainId,
+          poolAddress: this.poolAddress,
+          adapterAddress: params.adapterAddress,
+          inputs: params.inputs,
+          calls: params.calls,
+          reshields: params.reshields,
+          deadline: params.deadline
+        },
+        opts,
+        overrides
+      );
+    }
+  };
   // ===== Advanced =====
   /**
    * Advanced escape hatch for raw JoinSplit transaction building.
@@ -56591,8 +56972,8 @@ function UnlinkProvider({
       setState((prev2) => ({
         ...prev2,
         accounts,
-        activeAccount,
-        activeAccountIndex
+        activeAccount: activeAccount ?? prev2.activeAccount,
+        activeAccountIndex: activeAccountIndex ?? prev2.activeAccountIndex
       }));
     } catch (err) {
       console.error("[UnlinkProvider] refreshAccounts error", err);