@augustdigital/sdk 5.1.1 → 7.0.0

package/lib/modules/vaults/utils.js

@@ -528,51 +528,72 @@ async function generatePermitSignature(token, owner, spender, value, deadline, s
         provider: signer,
         abi: abis_1.ABI_TOKENIZED_VAULT_V2_RECEIPT,
     });
-    const [name, nonce] = await Promise.all([
-        tokenContract.name(),
-        tokenContract.nonces(owner),
+    const noncePromise = tokenContract.nonces(owner);
+    const domainSeparatorPromise = (async () => {
+        try {
+            return await tokenContract.DOMAIN_SEPARATOR();
+        }
+        catch (error) {
+            core_1.Logger.log.error('generatePermitSignature', error, {
+                message: 'Could not fetch DOMAIN_SEPARATOR from contract',
+            });
+            throw error;
+        }
+    })();
+    const [nonce, contractDomainSeparator] = await Promise.all([
+        noncePromise,
+        domainSeparatorPromise,
     ]);
     const valueBigInt = typeof value === 'string' ? BigInt(value) : value;
-    let contractDomainSeparator;
-    try {
-        contractDomainSeparator = await tokenContract.DOMAIN_SEPARATOR();
-    }
-    catch (error) {
-        console.error('Could not fetch DOMAIN_SEPARATOR from contract');
-        throw error;
-    }
-    const domainConfigs = [
-        { name, version: '1', chainId, verifyingContract: token },
-        { name, version: '2', chainId, verifyingContract: token },
-        { name, chainId, verifyingContract: token },
-        {
-            name,
-            version: '1',
-            chainId,
-            verifyingContract: token,
-            salt: ethers_1.ethers.zeroPadValue('0x', 32),
-        },
-    ];
+    const permitDomainCacheKey = `permit-domain-${chainId}-${token.toLowerCase()}`;
+    const cachedDomain = core_1.CACHE.get(permitDomainCacheKey);
     let matchingDomain = null;
-    for (const domain of domainConfigs) {
-        const computed = ethers_1.ethers.TypedDataEncoder.hashDomain(domain);
-        if (computed.toLowerCase() === contractDomainSeparator.toLowerCase()) {
-            matchingDomain = domain;
-            break;
+    if (cachedDomain) {
+        const cachedHash = ethers_1.ethers.TypedDataEncoder.hashDomain(cachedDomain);
+        if (cachedHash.toLowerCase() === contractDomainSeparator.toLowerCase()) {
+            matchingDomain = cachedDomain;
+        }
+        else {
+            core_1.CACHE.delete(permitDomainCacheKey);
         }
     }
     if (!matchingDomain) {
-        try {
-            const version = await tokenContract.version();
-            matchingDomain = { name, version, chainId, verifyingContract: token };
-            const computed = ethers_1.ethers.TypedDataEncoder.hashDomain(matchingDomain);
-            if (computed.toLowerCase() !== contractDomainSeparator.toLowerCase()) {
-                throw new Error('Could not match DOMAIN_SEPARATOR even with contract version');
+        const name = (await tokenContract.name());
+        const domainConfigs = [
+            { name, version: '1', chainId, verifyingContract: token },
+            { name, version: '2', chainId, verifyingContract: token },
+            { name, chainId, verifyingContract: token },
+            {
+                name,
+                version: '1',
+                chainId,
+                verifyingContract: token,
+                salt: ethers_1.ethers.zeroPadValue('0x', 32),
+            },
+        ];
+        for (const domain of domainConfigs) {
+            const computed = ethers_1.ethers.TypedDataEncoder.hashDomain(domain);
+            if (computed.toLowerCase() === contractDomainSeparator.toLowerCase()) {
+                matchingDomain = domain;
+                break;
             }
         }
-        catch {
-            throw new Error(`Could not determine correct domain configuration. Contract DOMAIN_SEPARATOR: ${contractDomainSeparator}`);
+        if (!matchingDomain) {
+            try {
+                const version = await tokenContract.version();
+                matchingDomain = { name, version, chainId, verifyingContract: token };
+                const computed = ethers_1.ethers.TypedDataEncoder.hashDomain(matchingDomain);
+                if (computed.toLowerCase() !== contractDomainSeparator.toLowerCase()) {
+                    throw new Error('Could not match DOMAIN_SEPARATOR even with contract version');
+                }
+            }
+            catch {
+                throw new Error(`Could not determine correct domain configuration. Contract DOMAIN_SEPARATOR: ${contractDomainSeparator}`);
+            }
         }
+        core_1.CACHE.set(permitDomainCacheKey, matchingDomain, {
+            ttl: 60 * 60 * 1000,
+        });
     }
     const types = {
         Permit: [

package/lib/modules/vaults/write.actions.d.ts

@@ -1,4 +1,4 @@
-import { Signer, Wallet } from 'ethers';
+import { Signer, Wallet, TransactionResponse } from 'ethers';
 import { IAddress } from '../../types';
 export type IContractWriteOptions = {
     target: IAddress;
@@ -17,7 +17,40 @@ export type INativeDepositOptions = {
     amount: string | bigint | number;
     wait?: boolean;
 };
-export declare function vaultApprove(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
+export declare function safeBigInt(value: unknown, context?: string): bigint;
+export declare function resolveDepositTokenDecimals(args: {
+    actualDepositAsset: IAddress;
+    underlyingAsset: IAddress;
+    isNativeToken: boolean;
+    isMultiAssetVault: boolean;
+    vaultDecimals: number;
+    readErc20Decimals: (address: IAddress) => Promise<number>;
+}): Promise<number>;
+export declare function resolveSpender(args: {
+    target: IAddress;
+    isMultiAssetVault: boolean;
+    isAdapterDeposit: boolean;
+    adapterWrapperAddress?: IAddress;
+}): IAddress;
+export declare function validateAmountPrecision(amount: string | bigint | number): void;
+export declare function isNonceParsing(error: unknown): boolean;
+export declare function safeWaitForTx(tx: TransactionResponse): Promise<import("ethers").TransactionReceipt>;
+export declare function safeSendTx(contractCall: () => Promise<TransactionResponse>, provider: Signer | Wallet, shouldWait?: boolean): Promise<{
+    tx: TransactionResponse | null;
+    hash: string;
+}>;
+export declare function tryRecoverTxHash(error: unknown, signer: Signer | Wallet, wait?: boolean): Promise<string | null>;
+export type ApproveResult = {
+    kind: 'sent';
+    hash: string;
+} | {
+    kind: 'sufficient';
+    existing: bigint;
+} | {
+    kind: 'native';
+};
+export declare function vaultApprove(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string | undefined>;
+export declare function approve(signer: Signer | Wallet, options: IContractWriteOptions): Promise<ApproveResult>;
 export declare function vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
 export declare function vaultRequestRedeem(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
 export declare function vaultRedeem(signer: Signer | Wallet, options: IContractWriteOptions & {