@gauntlet-xyz/sdk 3.0.1 → 3.1.1

package/dist/{chunk-7TA2OJUK.js → chunk-YQXTLIJA.js}

@@ -1,6 +1,3 @@
-import {
-  resolveVault
-} from "./chunk-STIV2CC4.js";
 import {
   AccountMismatchError,
   AccountRequiredError,
@@ -13,6 +10,7 @@ import {
   DEFAULT_MAX_PRICE_AGE,
   DEFAULT_REQUEST_DEADLINE_BUFFER,
   DEFAULT_SOLVER_TIP,
+  GauntletSDKError,
   InvalidSlippageBPSError,
   InvalidSolverTipError,
   InvalidSyncDepositBoundError,
@@ -26,8 +24,9 @@ import {
   UnsupportedFeatureError,
   UnsupportedProtocolError,
   VaultNotFoundError,
-  requireNonZeroSyncWithdrawBound
-} from "./chunk-HC2BS7MK.js";
+  requireNonZeroSyncWithdrawBound,
+  resolveVault
+} from "./chunk-JJOLVL5V.js";
 
 // src/evm/types.ts
 var ContractVersion = {
@@ -1507,7 +1506,6 @@ function readAtBlock(options = {}) {
 }
 
 // src/evm/aeraContracts.ts
-var contractVersionCache = /* @__PURE__ */ new Map();
 var contractVersionAbi = [
   {
     type: "function",
@@ -1543,9 +1541,6 @@ function applySlippageDown(amount, slippageBps) {
 function applySlippageUp(amount, slippageBps) {
   return (amount * (MAX_BPS + BigInt(slippageBps)) + MAX_BPS - 1n) / MAX_BPS;
 }
-function contractVersionCacheKey(client, address) {
-  return `${client.chain?.id ?? "unknown"}:${address.toLowerCase()}`;
-}
 function isVersionUnavailableError(error) {
   if (!(error instanceof ContractFunctionExecutionError) || error.functionName !== "version") {
     return false;
@@ -1563,10 +1558,22 @@ function getMultiDepositorVault(client, vaultAddress) {
     client
   });
 }
+var latestContractVersions = /* @__PURE__ */ new WeakMap();
 async function resolveContractVersion(client, address, options = {}) {
-  const cacheKey = contractVersionCacheKey(client, address);
-  const cached = contractVersionCache.get(cacheKey);
-  if (cached) return cached;
+  if (options.blockNumber !== void 0) return readContractVersion(client, address, options);
+  let versions = latestContractVersions.get(client);
+  if (versions === void 0) {
+    versions = /* @__PURE__ */ new Map();
+    latestContractVersions.set(client, versions);
+  }
+  const key = address.toLowerCase();
+  const cached = versions.get(key);
+  if (cached !== void 0) return cached;
+  const version = await readContractVersion(client, address, options);
+  versions.set(key, version);
+  return version;
+}
+async function readContractVersion(client, address, options) {
   try {
     const versionString = await client.readContract({
       address,
@@ -1574,12 +1581,14 @@ async function resolveContractVersion(client, address, options = {}) {
       functionName: "version",
       ...readAtBlock(options)
     });
-    const version = versionString.startsWith("2.") ? ContractVersion.V2 : ContractVersion.V1;
-    contractVersionCache.set(cacheKey, version);
-    return version;
+    if (!/^[12]\./.test(versionString)) {
+      throw new UnsupportedFeatureError(`Aera: unsupported contract version ${versionString}`);
+    }
+    return versionString.startsWith("2.") ? ContractVersion.V2 : ContractVersion.V1;
   } catch (error) {
     if (!isVersionUnavailableError(error)) throw error;
-    contractVersionCache.set(cacheKey, ContractVersion.V1);
+    const code = await client.getCode({ address, ...readAtBlock(options) });
+    if (code === void 0 || code === "0x") throw error;
     return ContractVersion.V1;
   }
 }
@@ -3262,16 +3271,25 @@ var aeraAdapter = {
       } else {
         throw new InvalidWithdrawParamsError();
       }
-      const tokenOutBeforeTip = await getAsyncRedeemTokenOut3(
-        publicClient,
-        runtime,
-        vault.vaultAddress,
-        asset.address,
-        shares
+      const tokensOut = "amount" in params && params.amount != null ? params.amount : subtractSolverTip(
+        await getAsyncRedeemTokenOut3(
+          publicClient,
+          runtime,
+          vault.vaultAddress,
+          asset.address,
+          shares
+        ),
+        solverTip
       );
-      minTokenOut = applySlippageDown(subtractSolverTip(tokenOutBeforeTip, solverTip), slippageBps);
+      minTokenOut = applySlippageDown(tokensOut, slippageBps);
       maxUnitsIn = shares;
     }
+    if (params.maxShares !== void 0) {
+      if (isAsync || typeof params.maxShares !== "bigint" || params.maxShares <= 0n || !isV2ExactTokenWithdraw && shares !== void 0 && shares > params.maxShares) {
+        throw new InvalidWithdrawParamsError();
+      }
+      if (maxUnitsIn > params.maxShares) maxUnitsIn = params.maxShares;
+    }
     const steps = [];
     if (isAsync) {
       if (shares === void 0) {
@@ -3562,7 +3580,7 @@ async function buildAttribution(client) {
       throw new UnimplementedFeatureError("AttributionMode.PRIVATE");
   }
 }
-async function encodeTransactionWithAttribution(client, transaction) {
+async function encodeTransactionWithAttribution(client, transaction, chainId) {
   const customAttribution = await buildAttribution(client);
   const encodedTx = encodeFunctionData({
     abi: transaction.abi,
@@ -3575,10 +3593,12 @@ async function encodeTransactionWithAttribution(client, transaction) {
       type: transaction.type,
       account: transaction.account,
       to: transaction.address,
+      chainId,
       data: encodedTxWithAttribution
     },
     tx: {
       ...transaction,
+      chainId,
       attribution: customAttribution
     }
   };
@@ -3620,6 +3640,7 @@ function resolveSyncOnlyOperationMode(vaultId, requested) {
 
 // src/evm/deposit.ts
 async function getDepositTx(client, params) {
+  params = structuredClone(params);
   const slippageBps = params.slippageBps ?? DEFAULT_BPS;
   if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > Number(MAX_BPS)) {
     throw new InvalidSlippageBPSError(slippageBps);
@@ -3661,7 +3682,7 @@ async function getDepositTx(client, params) {
     modifiedDepositMode = resolveSyncOnlyOperationMode(params.vaultId, requestedDepositMode);
   }
   const spender = protocol === "aera" && modifiedDepositMode === "async" ? aeraRuntime.provisioner.address : vault.vaultAddress;
-  const { sufficient } = await adapter.checkAllowance({
+  const { sufficient, current } = await adapter.checkAllowance({
     publicClient,
     token: token.address,
     owner: account,
@@ -3670,14 +3691,43 @@ async function getDepositTx(client, params) {
   });
   const steps = [];
   if (!sufficient) {
-    steps.push(
-      adapter.buildApproval({
-        token: token.address,
-        spender,
-        amount: params.amount,
-        account
-      })
-    );
+    const approval = adapter.buildApproval({
+      token: token.address,
+      spender,
+      amount: params.amount,
+      account
+    });
+    if (current > 0n && params.amount > 0n) {
+      try {
+        await publicClient.estimateContractGas({
+          address: approval.address,
+          abi: approval.abi,
+          functionName: "approve",
+          args: approval.args,
+          account
+        });
+      } catch (approvalError) {
+        const reset = adapter.buildApproval({
+          token: token.address,
+          spender,
+          amount: 0n,
+          account
+        });
+        try {
+          await publicClient.estimateContractGas({
+            address: reset.address,
+            abi: reset.abi,
+            functionName: "approve",
+            args: reset.args,
+            account
+          });
+        } catch {
+          throw approvalError;
+        }
+        steps.push(reset);
+      }
+    }
+    steps.push(approval);
   }
   const depositSteps = await adapter.buildDeposit({
     vault,
@@ -3694,11 +3744,12 @@ async function getDepositTx(client, params) {
     minUnitsOut: params.minUnitsOut
   });
   steps.push(...depositSteps);
-  return Promise.all(steps.map((step) => encodeTransactionWithAttribution(client, step)));
+  return Promise.all(steps.map((step) => encodeTransactionWithAttribution(client, step, chainId)));
 }
 
 // src/evm/depositReceiverApproval.ts
 async function getDepositReceiverApprovalTx(client, params) {
+  params = { ...params };
   const resolved = await resolveVault(client, params.vaultId, params.chainId);
   if (!resolved) throw new VaultNotFoundError(params.vaultId);
   const chainId = params.chainId ?? resolved.vault.chainId;
@@ -3710,15 +3761,19 @@ async function getDepositReceiverApprovalTx(client, params) {
   if (runtime.provisioner.version !== ContractVersion.V2) {
     throw new UnsupportedFeatureError("Aera: deposit receiver approval on V1");
   }
-  return encodeTransactionWithAttribution(client, {
-    type: "setDepositReceiverApproval",
-    ...setDepositReceiverApprovalTxRequest(
-      runtime.provisioner.address,
-      params.depositor,
-      params.approved ?? true,
-      receiver
-    )
-  });
+  return encodeTransactionWithAttribution(
+    client,
+    {
+      type: "setDepositReceiverApproval",
+      ...setDepositReceiverApprovalTxRequest(
+        runtime.provisioner.address,
+        params.depositor,
+        params.approved ?? true,
+        receiver
+      )
+    },
+    chainId
+  );
 }
 
 // src/evm/depositQuote.ts
@@ -3750,6 +3805,7 @@ async function resolveSyncDepositContext(client, params, readKind) {
   return { publicClient, vault, token, runtime };
 }
 async function getSyncDepositQuote2(client, params) {
+  params = structuredClone(params);
   const slippageBps = params.slippageBps ?? DEFAULT_BPS;
   if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > Number(MAX_BPS)) {
     throw new InvalidSlippageBPSError(slippageBps);
@@ -3784,6 +3840,12 @@ async function getSyncDepositRate(client, params) {
 
 // src/evm/withdraw.ts
 function validateWithdrawParams(params) {
+  if (params.entireAmount !== void 0 && typeof params.entireAmount !== "boolean") {
+    throw new InvalidWithdrawParamsError();
+  }
+  if (params.amount !== void 0 && params.amount < 0n || params.shares !== void 0 && params.shares < 0n) {
+    throw new InvalidWithdrawParamsError();
+  }
   const modes = [
     "amount" in params && params.amount != null,
     "shares" in params && params.shares != null,
@@ -3829,6 +3891,7 @@ function validateSyncWithdrawQuote({
   }
 }
 async function getWithdrawTx(client, params) {
+  params = structuredClone(params);
   validateWithdrawParams(params);
   if (params.slippageBps !== void 0 && (!Number.isInteger(params.slippageBps) || params.slippageBps < 0 || params.slippageBps > Number(MAX_BPS))) {
     throw new InvalidSlippageBPSError(params.slippageBps);
@@ -3844,6 +3907,9 @@ async function getWithdrawTx(client, params) {
     }
   }
   const { vault, protocol } = resolved;
+  if (params.maxShares !== void 0 && protocol !== "aera") {
+    throw new UnsupportedFeatureError("maxShares requires an Aera sync withdrawal");
+  }
   const token = vault.supplyToken.length > 1 ? vault.supplyToken.find((tInfo) => tInfo.symbol === params.assetSymbol) : vault.supplyToken[0];
   if (token === void 0) {
     throw new UnsupportedAssetError(params.assetSymbol ?? "unknown", params.vaultId);
@@ -3901,12 +3967,15 @@ async function getWithdrawTx(client, params) {
     maxPriceAge: params.maxPriceAge,
     aeraRuntime,
     syncWithdrawQuote: params.syncWithdrawQuote,
+    maxShares: params.maxShares,
     ..."shares" in params && params.shares != null ? { shares: params.shares } : {},
     ..."amount" in params && params.amount != null ? { amount: params.amount } : {},
     ..."entireAmount" in params && params.entireAmount ? { entireAmount: true } : {}
   };
   const steps = await adapter.buildWithdraw(withdrawParams);
-  return await Promise.all(steps.map((step) => encodeTransactionWithAttribution(client, step)));
+  return await Promise.all(
+    steps.map((step) => encodeTransactionWithAttribution(client, step, chainId))
+  );
 }
 
 // src/evm/withdrawQuote.ts
@@ -3976,6 +4045,7 @@ async function getSyncWithdrawRate(client, params) {
   );
 }
 async function getSyncWithdrawQuote(client, params) {
+  params = structuredClone(params);
   validateSyncWithdrawQuoteParams(params);
   if (params.slippageBps !== void 0 && (!Number.isInteger(params.slippageBps) || params.slippageBps < 0 || params.slippageBps > Number(MAX_BPS))) {
     throw new InvalidSlippageBPSError(params.slippageBps);
@@ -4149,6 +4219,7 @@ async function getAeraTokenModeSupport(client, params) {
 
 // src/evm/userCurrentBalance.ts
 import { parseAbi } from "viem";
+var LOG_CHUNK_CONCURRENCY = 16;
 var DEPOSIT_REQUESTED_V1_ABI = [
   {
     type: "event",
@@ -4196,71 +4267,105 @@ function dedupeByRequestHash(logs, hashKey) {
     return true;
   });
 }
-async function queryDeploymentBalance(client, deployment, address) {
+async function requestScanStart(publicClient, chainId, blockNumber, days, cutoff) {
+  let span = (BLOCKS_3_DAYS[chainId] ?? DEFAULT_BLOCKS_3_DAYS) * BigInt(days) / 3n;
+  for (; ; ) {
+    if (span >= blockNumber) return 0n;
+    const start = blockNumber - span;
+    const block = await publicClient.getBlock({ blockNumber: start });
+    if (block.timestamp <= cutoff) return start;
+    span *= 2n;
+  }
+}
+async function mapInBatches(items, size, fn) {
+  const results = [];
+  for (let i = 0; i < items.length; i += size) {
+    results.push(...await Promise.all(items.slice(i, i + size).map(fn)));
+  }
+  return results;
+}
+async function queryDeploymentBalance(client, deployment, params) {
   const publicClient = client.getPublicClient(deployment.chainId);
-  const token = deployment.supplyToken[0];
+  const { address } = params;
+  const token = deployment.supplyToken.length > 1 ? deployment.supplyToken.find((candidate) => candidate.symbol === params.assetSymbol) : deployment.supplyToken[0];
+  if (token === void 0)
+    throw new UnsupportedAssetError(params.assetSymbol ?? "unknown", params.vaultId);
+  const snapshot = await publicClient.getBlock({ blockTag: "latest" });
+  if (snapshot.number === null) {
+    throw new GauntletSDKError("The balance snapshot has no block number");
+  }
+  const blockNumber = snapshot.number;
+  const readOptions = { blockNumber };
+  const expirationDays = deployment.expirationDays ?? 3;
+  if (!Number.isSafeInteger(expirationDays) || expirationDays <= 0) {
+    throw new GauntletSDKError("The request expiration must be a positive integer number of days");
+  }
+  const scanDays = Math.max(3, expirationDays);
+  const cutoff = snapshot.timestamp - BigInt(DAY) * BigInt(scanDays);
+  const fromBlock = params.fromBlock ?? await requestScanStart(publicClient, deployment.chainId, blockNumber, scanDays, cutoff);
+  if (fromBlock < 0n || fromBlock > blockNumber) {
+    throw new GauntletSDKError("The request scan range is invalid");
+  }
   const vaultContract = getMultiDepositorVault(publicClient, deployment.vaultAddress);
   const [runtime, units] = await Promise.all([
-    resolveAeraRuntimeContracts(publicClient, deployment),
-    vaultContract.read.balanceOf([address])
+    resolveAeraRuntimeContracts(publicClient, deployment, readOptions),
+    vaultContract.read.balanceOf([address], readOptions)
   ]);
   const provisionerAddress = runtime.provisioner.address;
   const isV2 = runtime.provisioner.version === ContractVersion.V2;
-  const unitsLockedUntilPromise = isV2 ? getUserUnitsRefundableUntil(publicClient, provisionerAddress, address) : Promise.resolve(void 0);
+  const unitsLockedUntilPromise = isV2 ? getUserUnitsRefundableUntil(publicClient, provisionerAddress, address, readOptions) : Promise.resolve(void 0);
   const balance = await convertUnitsToToken(
     publicClient,
     runtime.feeCalculator.address,
     runtime.feeCalculator.version,
     deployment.vaultAddress,
     token.address,
-    units
+    units,
+    readOptions
   );
-  const currentBlock = await publicClient.getBlockNumber();
-  const lookback = BLOCKS_3_DAYS[deployment.chainId] ?? DEFAULT_BLOCKS_3_DAYS;
-  const fromBlock = currentBlock > lookback ? currentBlock - lookback : 0n;
   const chunks = [];
-  for (let cursor = fromBlock; cursor <= currentBlock; cursor += LOG_PAGE_SIZE + 1n) {
-    const end = cursor + LOG_PAGE_SIZE <= currentBlock ? cursor + LOG_PAGE_SIZE : currentBlock;
+  for (let cursor = fromBlock; cursor <= blockNumber; cursor += LOG_PAGE_SIZE + 1n) {
+    const end = cursor + LOG_PAGE_SIZE <= blockNumber ? cursor + LOG_PAGE_SIZE : blockNumber;
     chunks.push([cursor, end]);
   }
   const [depositPages, redeemPages] = await Promise.all([
-    Promise.all(
-      chunks.map(
-        ([from, to]) => isV2 ? publicClient.getContractEvents({
-          address: provisionerAddress,
-          abi: provisionerV2Abi,
-          eventName: "DepositRequested",
-          args: { receiver: address },
-          fromBlock: from,
-          toBlock: to
-        }) : publicClient.getContractEvents({
-          address: provisionerAddress,
-          abi: DEPOSIT_REQUESTED_V1_ABI,
-          eventName: "DepositRequested",
-          args: { user: address },
-          fromBlock: from,
-          toBlock: to
-        })
-      )
+    mapInBatches(
+      chunks,
+      LOG_CHUNK_CONCURRENCY,
+      ([from, to]) => isV2 ? publicClient.getContractEvents({
+        address: provisionerAddress,
+        abi: provisionerV2Abi,
+        eventName: "DepositRequested",
+        args: { receiver: address, token: token.address },
+        fromBlock: from,
+        toBlock: to
+      }) : publicClient.getContractEvents({
+        address: provisionerAddress,
+        abi: DEPOSIT_REQUESTED_V1_ABI,
+        eventName: "DepositRequested",
+        args: { user: address, token: token.address },
+        fromBlock: from,
+        toBlock: to
+      })
     ),
-    Promise.all(
-      chunks.map(
-        ([from, to]) => isV2 ? publicClient.getContractEvents({
-          address: provisionerAddress,
-          abi: provisionerV2Abi,
-          eventName: "RedeemRequested",
-          args: { user: address },
-          fromBlock: from,
-          toBlock: to
-        }) : publicClient.getContractEvents({
-          address: provisionerAddress,
-          abi: REDEEM_REQUESTED_V1_ABI,
-          eventName: "RedeemRequested",
-          args: { user: address },
-          fromBlock: from,
-          toBlock: to
-        })
-      )
+    mapInBatches(
+      chunks,
+      LOG_CHUNK_CONCURRENCY,
+      ([from, to]) => isV2 ? publicClient.getContractEvents({
+        address: provisionerAddress,
+        abi: provisionerV2Abi,
+        eventName: "RedeemRequested",
+        args: { user: address, token: token.address },
+        fromBlock: from,
+        toBlock: to
+      }) : publicClient.getContractEvents({
+        address: provisionerAddress,
+        abi: REDEEM_REQUESTED_V1_ABI,
+        eventName: "RedeemRequested",
+        args: { user: address, token: token.address },
+        fromBlock: from,
+        toBlock: to
+      })
     )
   ]);
   const depositLogs = dedupeByRequestHash(depositPages.flat(), "depositRequestHash");
@@ -4280,7 +4385,8 @@ async function queryDeploymentBalance(client, deployment, address) {
         args: [log.args.redeemRequestHash]
       }))
     ],
-    allowFailure: false
+    allowFailure: false,
+    blockNumber
   });
   const depositChecks = pendingChecks.slice(0, depositLogs.length);
   const redeemChecks = pendingChecks.slice(depositLogs.length);
@@ -4302,10 +4408,13 @@ async function queryDeploymentBalance(client, deployment, address) {
     runtime.feeCalculator.version,
     deployment.vaultAddress,
     token.address,
-    pendingWithdrawUnits
+    pendingWithdrawUnits,
+    readOptions
   ) : 0n;
   const unitsLockedUntil = await unitsLockedUntilPromise;
   return {
+    blockNumber,
+    fromBlock,
     chain: CHAIN_NAMES[deployment.chainId] ?? `chain-${deployment.chainId}`,
     chainId: deployment.chainId,
     token: token.address,
@@ -4317,6 +4426,7 @@ async function queryDeploymentBalance(client, deployment, address) {
   };
 }
 async function getUserCurrentBalance(client, params) {
+  params = { ...params };
   const manifest = await client.manifest;
   const vaultInfo = manifest.vaults.find((v) => v.vaultId === params.vaultId);
   if (!vaultInfo) throw new VaultNotFoundError(params.vaultId);
@@ -4334,9 +4444,12 @@ async function getUserCurrentBalance(client, params) {
         evmDeployments.map((d) => `${d.chainId}`).join(", ")
       );
     }
-    return [await queryDeploymentBalance(client, deployment, params.address)];
+    return [await queryDeploymentBalance(client, deployment, params)];
+  }
+  if (params.fromBlock !== void 0 && evmDeployments.length > 1) {
+    throw new GauntletSDKError("fromBlock requires chainId for a vault with several deployments");
   }
-  return Promise.all(evmDeployments.map((d) => queryDeploymentBalance(client, d, params.address)));
+  return Promise.all(evmDeployments.map((d) => queryDeploymentBalance(client, d, params)));
 }
 
 export {
@@ -4361,4 +4474,4 @@ export {
   getAeraTokenModeSupport,
   getUserCurrentBalance
 };
-//# sourceMappingURL=chunk-7TA2OJUK.js.map
+//# sourceMappingURL=chunk-YQXTLIJA.js.map