@paxoslabs/amplify-sdk 0.1.1 → 0.2.0-alpha.0

package/dist/index.mjs

@@ -1,13 +1,14 @@
-import { DEFAULT_SLIPPAGE_BPS } from './chunk-XXHRCCZS.mjs';
-export { YieldType } from './chunk-XXHRCCZS.mjs';
-export { getDepositExchangeRate, getWithdrawExchangeRate, isDepositSpendApproved, isWithdrawalSpendApproved } from './chunk-HI44AMLC.mjs';
-import { getRateInQuoteWithAssetDecimals, getClient, BoringVaultAbi, getRateInQuoteAndSharesAndWantAssetDecimals, TellerAbi } from './chunk-ZILA73XN.mjs';
+import { DEFAULT_SLIPPAGE_BPS } from './chunk-AQFFMJX7.mjs';
+export { YieldType } from './chunk-AQFFMJX7.mjs';
+import { isDepositSpendApproved } from './chunk-E7R7TL7J.mjs';
+export { getDepositExchangeRate, getWithdrawExchangeRate, isDepositSpendApproved, isWithdrawalSpendApproved } from './chunk-E7R7TL7J.mjs';
+import { getRateInQuoteWithAssetDecimals, getClient, erc2612Abi, BoringVaultAbi, getRateInQuoteAndSharesAndWantAssetDecimals, TellerAbi } from './chunk-5Y7M43XN.mjs';
 import './chunk-R663BFAZ.mjs';
 import { toChainId } from './chunk-J3662HYT.mjs';
-import { calculateDeadline } from './chunk-REKEQLQA.mjs';
+import { calculateDeadline } from './chunk-BOW2QPQC.mjs';
 import { WAD } from './chunk-7RWWVUHP.mjs';
-import { findVaultByConfig, APIError, getAssetsFromCache, DEFAULT_APPROVAL_AMOUNT, fetchSupportedAssets, ATOMIC_QUEUE_CONTRACT_ADDRESS, DEFAULT_DEADLINE } from './chunk-CUGK4ZBJ.mjs';
-export { APIError, fetchSupportedAssets, fetchVaults, findVaultByConfig, getAssetsFromCache, getCache, getWithdrawSupportedAssets, initAmplifySDK, initializeCache, refreshVaultCache } from './chunk-CUGK4ZBJ.mjs';
+import { findVaultByConfig, APIError, getAssetsFromCache, DEFAULT_APPROVAL_AMOUNT, fetchSupportedAssets, ATOMIC_QUEUE_CONTRACT_ADDRESS, DEFAULT_DEADLINE } from './chunk-IMS2HBJ7.mjs';
+export { APIError, LogLevel, fetchSupportedAssets, fetchVaults, findVaultByConfig, getAssetsFromCache, getCache, getLogger, getWithdrawSupportedAssets, initAmplifySDK, initializeCache, refreshVaultCache, setLogLevel, setLogger } from './chunk-IMS2HBJ7.mjs';
 import { parseUnits, erc20Abi, stringToHex, hexToSignature } from 'viem';
 
 async function prepareApproveDepositTokenTxData({
@@ -433,56 +434,6 @@ async function prepareDepositTxData(params) {
     );
   }
 }
-
-// src/abi/erc2612-abi.ts
-var erc2612Abi = [
-  // Standard ERC20 functions (subset needed for permit flow)
-  {
-    constant: true,
-    inputs: [{ name: "_owner", type: "address" }],
-    name: "nonces",
-    outputs: [{ name: "", type: "uint256" }],
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "DOMAIN_SEPARATOR",
-    outputs: [{ name: "", type: "bytes32" }],
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" },
-      { name: "value", type: "uint256" },
-      { name: "deadline", type: "uint256" },
-      { name: "v", type: "uint8" },
-      { name: "r", type: "bytes32" },
-      { name: "s", type: "bytes32" }
-    ],
-    name: "permit",
-    outputs: [],
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "name",
-    outputs: [{ name: "", type: "string" }],
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "version",
-    outputs: [{ name: "", type: "string" }],
-    type: "function"
-  }
-];
-
-// src/vaults/deposit/deposit-with-permit.ts
 var PERMIT_TYPES = {
   Permit: [
     { name: "owner", type: "address" },
@@ -499,7 +450,12 @@ async function prepareDepositPermitSignature(params) {
     depositAmount,
     recipientAddress,
     chainId,
-    deadline
+    deadline,
+    // Optional pre-fetched data to skip RPC calls
+    nonce: prefetchedNonce,
+    decimals: prefetchedDecimals,
+    tokenName: prefetchedTokenName,
+    tokenVersion: prefetchedTokenVersion
   } = params;
   try {
     const normalizedChainId = toChainId(chainId);
@@ -534,79 +490,102 @@ async function prepareDepositPermitSignature(params) {
         { endpoint: "prepareDepositPermitSignature" }
       );
     }
-    const client = await getClient(normalizedChainId);
-    let tokenName;
-    let tokenVersion;
-    let nonce;
-    try {
-      const [nameResult, versionResult, nonceResult] = await Promise.allSettled(
-        [
-          client.readContract({
-            address: depositToken,
-            abi: erc2612Abi,
-            functionName: "name"
-          }),
-          client.readContract({
-            address: depositToken,
-            abi: erc2612Abi,
-            functionName: "version"
-          }),
-          client.readContract({
-            address: depositToken,
-            abi: erc2612Abi,
-            functionName: "nonces",
-            args: [recipientAddress]
-          })
-        ]
-      );
-      if (nameResult.status === "fulfilled") {
-        tokenName = nameResult.value;
-      } else {
-        throw new APIError(`Failed to read token name from ${depositToken}`, {
-          endpoint: "prepareDepositPermitSignature",
-          cause: nameResult.reason
-        });
-      }
-      if (versionResult.status === "fulfilled") {
-        tokenVersion = versionResult.value;
-      } else {
-        tokenVersion = "1";
-      }
-      if (nonceResult.status === "fulfilled") {
-        nonce = nonceResult.value;
-      } else {
+    let resolvedTokenName;
+    let resolvedTokenVersion;
+    let resolvedNonce;
+    const hasAllPrefetchedData = prefetchedTokenName !== void 0 && prefetchedTokenVersion !== void 0 && prefetchedNonce !== void 0;
+    if (hasAllPrefetchedData) {
+      resolvedTokenName = prefetchedTokenName;
+      resolvedTokenVersion = prefetchedTokenVersion;
+      resolvedNonce = prefetchedNonce;
+    } else {
+      const client = await getClient(normalizedChainId);
+      try {
+        const [nameResult, versionResult, nonceResult] = await client.multicall(
+          {
+            contracts: [
+              {
+                address: depositToken,
+                abi: erc2612Abi,
+                functionName: "name"
+              },
+              {
+                address: depositToken,
+                abi: erc2612Abi,
+                functionName: "version"
+              },
+              {
+                address: depositToken,
+                abi: erc2612Abi,
+                functionName: "nonces",
+                args: [recipientAddress]
+              }
+            ]
+          }
+        );
+        if (prefetchedTokenName !== void 0) {
+          resolvedTokenName = prefetchedTokenName;
+        } else if (nameResult.status === "success") {
+          resolvedTokenName = nameResult.result;
+        } else {
+          throw new APIError(`Failed to read token name from ${depositToken}`, {
+            endpoint: "prepareDepositPermitSignature",
+            cause: nameResult.error
+          });
+        }
+        if (prefetchedTokenVersion !== void 0) {
+          resolvedTokenVersion = prefetchedTokenVersion;
+        } else if (versionResult.status === "success") {
+          resolvedTokenVersion = versionResult.result;
+        } else {
+          resolvedTokenVersion = "1";
+        }
+        if (prefetchedNonce !== void 0) {
+          resolvedNonce = prefetchedNonce;
+        } else if (nonceResult.status === "success") {
+          resolvedNonce = nonceResult.result;
+        } else {
+          throw new APIError(
+            `Token ${depositToken} does not support EIP-2612 permit. Missing required function: nonces()`,
+            {
+              endpoint: "prepareDepositPermitSignature",
+              cause: nonceResult.error
+            }
+          );
+        }
+      } catch (error) {
+        if (error instanceof APIError) {
+          throw error;
+        }
         throw new APIError(
-          `Token ${depositToken} does not support EIP-2612 permit. Missing required function: nonces()`,
+          `Failed to read token metadata: ${error instanceof Error ? error.message : "Unknown error"}`,
           {
             endpoint: "prepareDepositPermitSignature",
-            cause: nonceResult.reason
+            cause: error
           }
         );
       }
-    } catch (error) {
-      if (error instanceof APIError) {
-        throw error;
-      }
-      throw new APIError(
-        `Failed to read token metadata: ${error instanceof Error ? error.message : "Unknown error"}`,
-        {
-          endpoint: "prepareDepositPermitSignature",
-          cause: error
-        }
-      );
     }
     const permitDeadline = deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 3600);
-    const assets = await fetchSupportedAssets({ address: depositToken });
-    if (assets.length === 0) {
-      throw new APIError(`Asset metadata not found for token ${depositToken}`, {
-        endpoint: "prepareDepositPermitSignature"
-      });
+    let resolvedDecimals;
+    if (prefetchedDecimals !== void 0) {
+      resolvedDecimals = prefetchedDecimals;
+    } else {
+      const assets = await fetchSupportedAssets({ address: depositToken });
+      if (assets.length === 0) {
+        throw new APIError(
+          `Asset metadata not found for token ${depositToken}`,
+          {
+            endpoint: "prepareDepositPermitSignature"
+          }
+        );
+      }
+      resolvedDecimals = assets[0].decimals;
     }
-    const asset = assets[0];
-    const value = parseUnits(depositAmount, asset.decimals);
+    const value = parseUnits(depositAmount, resolvedDecimals);
     const domain = {
-      name: tokenName,
-      version: tokenVersion,
+      name: resolvedTokenName,
+      version: resolvedTokenVersion,
       chainId: normalizedChainId,
       verifyingContract: depositToken
     };
@@ -614,7 +593,7 @@ async function prepareDepositPermitSignature(params) {
       owner: recipientAddress,
       spender: communityCodeDepositorAddress,
       value,
-      nonce,
+      nonce: resolvedNonce,
       deadline: permitDeadline
     };
     return {
@@ -810,6 +789,196 @@ async function prepareDepositWithPermitTxData(params) {
     );
   }
 }
+var DepositAuthMethod = {
+  PERMIT: "permit",
+  APPROVAL: "approval",
+  ALREADY_APPROVED: "already_approved"
+};
+async function prepareDepositAuthorization(params) {
+  const {
+    yieldType,
+    depositToken,
+    depositAmount,
+    recipientAddress,
+    chainId,
+    deadline,
+    forceMethod
+  } = params;
+  try {
+    const normalizedChainId = toChainId(chainId);
+    const vault = await findVaultByConfig({
+      assetAddress: depositToken,
+      yieldType,
+      chainId: normalizedChainId
+    });
+    if (!vault) {
+      throw new APIError(
+        `No vault found for token ${depositToken} with yield type '${yieldType}' on chain ${normalizedChainId}`,
+        { endpoint: "prepareDepositAuthorization" }
+      );
+    }
+    const tokenInfo = await isDepositSpendApproved({
+      yieldType,
+      chainId: normalizedChainId,
+      depositAssetAddress: depositToken,
+      recipientAddress
+    });
+    if (forceMethod === "permit") {
+      const permitData = await prepareDepositPermitSignature({
+        yieldType,
+        depositToken,
+        depositAmount,
+        recipientAddress,
+        chainId: normalizedChainId,
+        deadline,
+        // Pass pre-fetched data to avoid redundant RPC calls
+        nonce: tokenInfo.nonce ?? void 0,
+        decimals: tokenInfo.decimals,
+        tokenName: tokenInfo.tokenName,
+        tokenVersion: tokenInfo.tokenVersion
+      });
+      return {
+        method: DepositAuthMethod.PERMIT,
+        permitData
+      };
+    }
+    if (forceMethod === "approval") {
+      const txData2 = await prepareApproveDepositTokenTxData({
+        yieldType,
+        depositToken,
+        approvalAmount: depositAmount,
+        chainId: normalizedChainId
+      });
+      return {
+        method: DepositAuthMethod.APPROVAL,
+        txData: txData2,
+        currentAllowance: tokenInfo.allowance,
+        currentAllowanceAsBigInt: tokenInfo.allowanceAsBigInt
+      };
+    }
+    if (tokenInfo.supportsPermit) {
+      const permitData = await prepareDepositPermitSignature({
+        yieldType,
+        depositToken,
+        depositAmount,
+        recipientAddress,
+        chainId: normalizedChainId,
+        deadline,
+        // Pass pre-fetched data to avoid redundant RPC calls
+        nonce: tokenInfo.nonce ?? void 0,
+        decimals: tokenInfo.decimals,
+        tokenName: tokenInfo.tokenName,
+        tokenVersion: tokenInfo.tokenVersion
+      });
+      return {
+        method: DepositAuthMethod.PERMIT,
+        permitData
+      };
+    }
+    const depositAmountBigInt = parseUnits(depositAmount, tokenInfo.decimals);
+    const currentAllowanceBigInt = BigInt(tokenInfo.allowanceAsBigInt);
+    if (tokenInfo.isApproved && currentAllowanceBigInt >= depositAmountBigInt) {
+      return {
+        method: DepositAuthMethod.ALREADY_APPROVED,
+        allowance: tokenInfo.allowance,
+        allowanceAsBigInt: tokenInfo.allowanceAsBigInt
+      };
+    }
+    const txData = await prepareApproveDepositTokenTxData({
+      yieldType,
+      depositToken,
+      approvalAmount: depositAmount,
+      chainId: normalizedChainId
+    });
+    return {
+      method: DepositAuthMethod.APPROVAL,
+      txData,
+      currentAllowance: tokenInfo.allowance,
+      currentAllowanceAsBigInt: tokenInfo.allowanceAsBigInt
+    };
+  } catch (error) {
+    if (error instanceof APIError) {
+      throw error;
+    }
+    throw new APIError(
+      `Failed to prepare deposit authorization: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareDepositAuthorization",
+        cause: error
+      }
+    );
+  }
+}
+async function prepareDeposit(params) {
+  const {
+    yieldType,
+    depositToken,
+    depositAmount,
+    recipientAddress,
+    chainId,
+    slippage,
+    partnerCode,
+    signature,
+    deadline,
+    forceMethod
+  } = params;
+  try {
+    if (forceMethod === "permit" && (!signature || deadline === void 0)) {
+      throw new APIError(
+        "Permit deposit requires both signature and deadline parameters when forceMethod is 'permit'",
+        { endpoint: "prepareDeposit" }
+      );
+    }
+    const usePermit = forceMethod === "permit" || forceMethod !== "approval" && signature !== void 0 && deadline !== void 0;
+    if (usePermit) {
+      if (!signature || deadline === void 0) {
+        throw new APIError(
+          "Permit deposit requires both signature and deadline parameters",
+          { endpoint: "prepareDeposit" }
+        );
+      }
+      const txData2 = await prepareDepositWithPermitTxData({
+        yieldType,
+        depositToken,
+        depositAmount,
+        recipientAddress,
+        chainId,
+        signature,
+        deadline,
+        slippage,
+        partnerCode
+      });
+      return {
+        method: DepositAuthMethod.PERMIT,
+        txData: txData2
+      };
+    }
+    const txData = await prepareDepositTxData({
+      yieldType,
+      depositToken,
+      depositAmount,
+      recipientAddress,
+      chainId,
+      slippage,
+      partnerCode
+    });
+    return {
+      method: DepositAuthMethod.APPROVAL,
+      txData
+    };
+  } catch (error) {
+    if (error instanceof APIError) {
+      throw error;
+    }
+    throw new APIError(
+      `Failed to prepare deposit: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareDeposit",
+        cause: error
+      }
+    );
+  }
+}
 async function prepareApproveWithdrawTxData({
   yieldType,
   wantAssetAddress,
@@ -1306,6 +1475,6 @@ var prepareWithdrawTxData = async ({
   }
 };
 
-export { PERMIT_TYPES, parsePermitSignature, prepareApproveDepositTokenTxData, prepareApproveWithdrawTxData, prepareBulkWithdrawTxData, prepareDepositPermitSignature, prepareDepositTxData, prepareDepositWithPermitTxData, prepareWithdrawTxData };
+export { DepositAuthMethod, PERMIT_TYPES, parsePermitSignature, prepareApproveDepositTokenTxData, prepareApproveWithdrawTxData, prepareBulkWithdrawTxData, prepareDeposit, prepareDepositAuthorization, prepareDepositPermitSignature, prepareDepositTxData, prepareDepositWithPermitTxData, prepareWithdrawTxData };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map