@augustdigital/sdk 6.0.1 → 7.0.0

package/lib/modules/vaults/write.actions.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeBigInt = safeBigInt;
+exports.resolveDepositTokenDecimals = resolveDepositTokenDecimals;
+exports.resolveSpender = resolveSpender;
+exports.validateAmountPrecision = validateAmountPrecision;
+exports.isNonceParsing = isNonceParsing;
+exports.safeWaitForTx = safeWaitForTx;
+exports.safeSendTx = safeSendTx;
+exports.tryRecoverTxHash = tryRecoverTxHash;
 exports.vaultApprove = vaultApprove;
+exports.approve = approve;
 exports.vaultDeposit = vaultDeposit;
 exports.vaultRequestRedeem = vaultRequestRedeem;
 exports.vaultRedeem = vaultRedeem;
@@ -9,22 +18,57 @@ exports.rwaRedeemAsset = rwaRedeemAsset;
 const ethers_1 = require("ethers");
 const abis_1 = require("../../abis");
 const core_1 = require("../../core");
-const read_actions_1 = require("./read.actions");
 const adapter_helpers_1 = require("./adapter.helpers");
 const utils_1 = require("./utils");
-function safeBigInt(value) {
+function safeBigInt(value, context = 'safeBigInt') {
     if (value === null || value === undefined)
         return 0n;
     const s = String(value);
-    if (s === '0x' || s === '')
+    if (s === '' || s === '0x') {
+        if (s === '0x') {
+            core_1.Logger.log.warn(context, 'RPC returned bare "0x"; treating as 0', {
+                raw: s,
+            });
+        }
         return 0n;
+    }
     try {
         return BigInt(s);
     }
-    catch {
+    catch (err) {
+        core_1.Logger.log.warn(context, 'Could not parse RPC value as BigInt; treating as 0', { raw: s, error: String(err) });
         return 0n;
     }
 }
+async function resolveDepositTokenDecimals(args) {
+    const { actualDepositAsset, underlyingAsset, isNativeToken, isMultiAssetVault, vaultDecimals, readErc20Decimals, } = args;
+    if (isNativeToken)
+        return 18;
+    const isUnderlying = actualDepositAsset.toLowerCase() === underlyingAsset.toLowerCase();
+    if (isUnderlying && !isMultiAssetVault)
+        return vaultDecimals;
+    return readErc20Decimals(actualDepositAsset);
+}
+function resolveSpender(args) {
+    if (args.isMultiAssetVault)
+        return args.target;
+    if (args.isAdapterDeposit && args.adapterWrapperAddress)
+        return args.adapterWrapperAddress;
+    return args.target;
+}
+function validateAmountPrecision(amount) {
+    if (typeof amount === 'string' || typeof amount === 'bigint')
+        return;
+    if (!Number.isFinite(amount)) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `amount must be finite, got ${amount}`);
+    }
+    if (amount < 0) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `amount must be non-negative, got ${amount}`);
+    }
+    if (Number.isInteger(amount) && !Number.isSafeInteger(amount)) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `amount ${amount} exceeds Number.MAX_SAFE_INTEGER; pass a string or bigint to preserve precision`);
+    }
+}
 const SAFE_WAIT_TIMEOUT_MS = 120000;
 function isNonceParsing(error) {
     const code = error?.code;
@@ -100,64 +144,142 @@ async function tryRecoverTxHash(error, signer, wait) {
     }
     return txHash;
 }
-async function vaultApprove(signer, options) {
-    const { wallet, target, wait, amount } = options;
+async function approveCore(signer, options) {
+    const { wallet, target, wait, amount, depositAsset } = options;
     const [goodWallet, goodPool] = [
         (0, core_1.checkAddress)(wallet, console, 'wallet'),
         (0, core_1.checkAddress)(target, console),
     ];
-    if (!goodWallet || !goodPool || !amount)
-        return;
-    const _allowance = await (0, read_actions_1.vaultAllowance)(signer, { target, wallet });
-    if (!_allowance || _allowance?.raw === '0') {
-        try {
-            const poolContract = (0, core_1.createContract)({
+    if (!goodWallet || !goodPool) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `vaultApprove: invalid ${!goodWallet ? 'wallet' : 'target'} address`);
+    }
+    if (amount === undefined || amount === null) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'vaultApprove: amount is required');
+    }
+    validateAmountPrecision(amount);
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(target))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const adapterConfig = (0, core_1.getVaultAdapterConfig)(target);
+        const isMultiAssetVault = vaultVersion === 'evm-2';
+        const poolContract = isMultiAssetVault
+            ? (0, core_1.createContract)({
+                address: target,
+                provider: signer,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            })
+            : (0, core_1.createContract)({
                 address: target,
                 provider: signer,
                 abi: abis_1.ABI_LENDING_POOLS,
             });
-            const [asset, rawDecimals] = await Promise.all([
+        let underlyingAsset;
+        let vaultDecimals;
+        if (isMultiAssetVault) {
+            const [asset, receiptTokenAddr] = await Promise.all([
                 poolContract.asset(),
-                poolContract.decimals(),
+                poolContract.lpTokenAddress(),
             ]);
-            const decimals = Number(rawDecimals);
-            const normalizedAmt = (0, core_1.toNormalizedBn)(amount, decimals);
-            const depositTokenContract = (0, core_1.createContract)({
-                address: asset,
-                abi: abis_1.ABI_ERC20,
+            underlyingAsset = asset;
+            const receiptContract = (0, core_1.createContract)({
+                address: receiptTokenAddr,
                 provider: signer,
+                abi: abis_1.ABI_ERC20,
             });
-            const { hash: approvalHash } = await safeSendTx(() => depositTokenContract
-                .connect(signer)
-                .approve(target, normalizedAmt.raw), signer, wait);
-            core_1.Logger.log.info('approve:tx_hash', approvalHash);
-            return approvalHash;
+            vaultDecimals = Number(await receiptContract.decimals());
         }
-        catch (e) {
-            core_1.Logger.log.error('approve', e, { target, amount });
-            throw new Error(`Approval failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+        else {
+            const [asset, rawDecimals] = await Promise.all([
+                poolContract.asset(),
+                poolContract.decimals(),
+            ]);
+            underlyingAsset = asset;
+            vaultDecimals = Number(rawDecimals);
         }
+        const actualDepositAsset = (depositAsset || underlyingAsset);
+        const isNativeToken = actualDepositAsset === ethers_1.ZeroAddress ||
+            actualDepositAsset === '0x0000000000000000000000000000000000000000';
+        if (isNativeToken)
+            return { kind: 'native' };
+        const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
+        const spenderAddress = resolveSpender({
+            target,
+            isMultiAssetVault,
+            isAdapterDeposit,
+            adapterWrapperAddress: adapterConfig?.wrapperAddress,
+        });
+        const depositTokenDecimals = await resolveDepositTokenDecimals({
+            actualDepositAsset,
+            underlyingAsset,
+            isNativeToken: false,
+            isMultiAssetVault,
+            vaultDecimals,
+            readErc20Decimals: async (addr) => {
+                const erc20 = (0, core_1.createContract)({
+                    address: addr,
+                    provider: signer,
+                    abi: abis_1.ABI_ERC20,
+                });
+                return Number(await erc20.decimals());
+            },
+        });
+        const normalizedAmt = (0, core_1.toNormalizedBn)(amount, depositTokenDecimals);
+        const needed = BigInt(normalizedAmt.raw);
+        const tokenContract = (0, core_1.createContract)({
+            address: actualDepositAsset,
+            abi: abis_1.ABI_ERC20,
+            provider: signer,
+        });
+        const currentAllowance = await tokenContract.allowance(wallet, spenderAddress);
+        const existing = safeBigInt(currentAllowance, 'vaultApprove:allowance');
+        if (existing >= needed) {
+            core_1.Logger.log.info('approve:allowance-sufficient', {
+                target,
+                spender: spenderAddress,
+                amount,
+            });
+            return { kind: 'sufficient', existing };
+        }
+        const { hash: approvalHash } = await safeSendTx(() => tokenContract
+            .connect(signer)
+            .approve(spenderAddress, normalizedAmt.raw), signer, wait);
+        core_1.Logger.log.info('approve:tx_hash', approvalHash);
+        return { kind: 'sent', hash: approvalHash };
     }
-    else {
-        core_1.Logger.log.info('approve:allowance', _allowance.normalized, 'amount:', amount);
+    catch (e) {
+        if (e instanceof core_1.AugustSDKError)
+            throw e;
+        core_1.Logger.log.error('vaultApprove', e, { target, amount });
+        throw new core_1.AugustSDKError('UNKNOWN', `Approval failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, amount } });
     }
 }
+async function vaultApprove(signer, options) {
+    const result = await approveCore(signer, options);
+    return result.kind === 'sent' ? result.hash : undefined;
+}
+async function approve(signer, options) {
+    return approveCore(signer, options);
+}
 async function vaultDeposit(signer, options) {
     const { wallet, target, wait, amount, depositAsset, chainId, poolName } = options;
     const [goodWallet, goodPool] = [
         (0, core_1.checkAddress)(wallet, console, 'wallet'),
         (0, core_1.checkAddress)(target, console),
     ];
-    if (!goodWallet || !goodPool)
-        return;
+    if (!goodWallet || !goodPool) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `vaultDeposit: invalid ${!goodWallet ? 'wallet' : 'target'} address`);
+    }
+    if (amount === undefined || amount === null) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'vaultDeposit: amount is required');
+    }
+    validateAmountPrecision(amount);
     try {
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(target))?.[0];
         const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
         const adapterConfig = (0, core_1.getVaultAdapterConfig)(target);
         let poolContract;
         let underlyingAsset;
-        let decimals;
-        let depositTokenDecimals;
+        let vaultDecimals;
         if (vaultVersion === 'evm-2') {
             poolContract = (0, core_1.createContract)({
                 address: target,
@@ -176,7 +298,7 @@ async function vaultDeposit(signer, options) {
                 provider: signer,
                 abi: abis_1.ABI_ERC20,
             });
-            decimals = Number(await receiptContract.decimals());
+            vaultDecimals = Number(await receiptContract.decimals());
         }
         else {
             poolContract = (0, core_1.createContract)({
@@ -188,7 +310,7 @@ async function vaultDeposit(signer, options) {
                 poolContract.asset(),
                 poolContract.decimals(),
             ]);
-            decimals = Number(rawDecimals);
+            vaultDecimals = Number(rawDecimals);
             underlyingAsset = fetchedUnderlyingAsset;
         }
         const actualDepositAsset = depositAsset || underlyingAsset;
@@ -196,39 +318,43 @@ async function vaultDeposit(signer, options) {
             actualDepositAsset === '0x0000000000000000000000000000000000000000';
         const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
         const isMultiAssetVault = vaultVersion === 'evm-2';
-        if (isAdapterDeposit && !isNativeToken) {
-            const depositTokenContract = (0, core_1.createContract)({
-                address: actualDepositAsset,
-                provider: signer,
-                abi: abis_1.ABI_ERC20,
-            });
-            depositTokenDecimals = Number(await depositTokenContract.decimals());
+        if (isAdapterDeposit && !isMultiAssetVault && !adapterConfig) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `vaultDeposit: depositAsset ${actualDepositAsset} differs from vault underlying ${underlyingAsset} but no adapter is configured for vault ${target}`);
         }
-        else {
-            depositTokenDecimals = decimals;
-        }
-        const normalizedAmt = (0, core_1.toNormalizedBn)(amount, isNativeToken ? decimals : depositTokenDecimals);
+        const depositTokenDecimals = await resolveDepositTokenDecimals({
+            actualDepositAsset,
+            underlyingAsset,
+            isNativeToken,
+            isMultiAssetVault,
+            vaultDecimals,
+            readErc20Decimals: async (addr) => {
+                const erc20 = (0, core_1.createContract)({
+                    address: addr,
+                    provider: signer,
+                    abi: abis_1.ABI_ERC20,
+                });
+                return Number(await erc20.decimals());
+            },
+        });
+        const normalizedAmt = (0, core_1.toNormalizedBn)(amount, depositTokenDecimals);
         if (!isNativeToken) {
-            let spenderAddress;
-            if (isMultiAssetVault) {
-                spenderAddress = target;
-            }
-            else if (isAdapterDeposit && adapterConfig?.wrapperAddress) {
-                spenderAddress = adapterConfig.wrapperAddress;
-            }
-            else {
-                spenderAddress = target;
-            }
+            const spenderAddress = resolveSpender({
+                target,
+                isMultiAssetVault,
+                isAdapterDeposit,
+                adapterWrapperAddress: adapterConfig?.wrapperAddress,
+            });
             const depositTokenContract = (0, core_1.createContract)({
                 address: actualDepositAsset,
                 provider: signer,
                 abi: abis_1.ABI_ERC20,
             });
             const currentAllowance = await depositTokenContract.allowance(wallet, spenderAddress);
-            if (safeBigInt(currentAllowance) < BigInt(normalizedAmt.raw)) {
+            if (safeBigInt(currentAllowance, 'vaultDeposit:allowance') <
+                BigInt(normalizedAmt.raw)) {
                 const { hash: approveHash } = await safeSendTx(() => depositTokenContract
                     .connect(signer)
-                    .approve(spenderAddress, normalizedAmt.raw), signer, wait);
+                    .approve(spenderAddress, normalizedAmt.raw), signer, true);
                 core_1.Logger.log.info('approve:tx_hash', approveHash);
             }
         }
@@ -254,7 +380,7 @@ async function vaultDeposit(signer, options) {
                     srcToken: actualDepositAsset,
                     srcDecimals: depositTokenDecimals,
                     destToken: underlyingAsset,
-                    destDecimals: decimals,
+                    destDecimals: vaultDecimals,
                     amount: normalizedAmt.raw.toString(),
                     network: chainId?.toString() || '1',
                     adapterConfig,
@@ -308,8 +434,10 @@ async function vaultDeposit(signer, options) {
             core_1.Logger.log.warn('deposit:nonce-fallback', { hash: recovered });
             return recovered;
         }
+        if (e instanceof core_1.AugustSDKError)
+            throw e;
         core_1.Logger.log.error('deposit', e, { target, amount, depositAsset });
-        throw new Error(`Deposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+        throw new core_1.AugustSDKError('UNKNOWN', `Deposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, amount, depositAsset } });
     }
 }
 async function vaultRequestRedeem(signer, options) {
@@ -318,8 +446,13 @@ async function vaultRequestRedeem(signer, options) {
         (0, core_1.checkAddress)(wallet, console, 'wallet'),
         (0, core_1.checkAddress)(target, console),
     ];
-    if (!goodWallet || !goodPool)
-        return;
+    if (!goodWallet || !goodPool) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `vaultRequestRedeem: invalid ${!goodWallet ? 'wallet' : 'target'} address`);
+    }
+    if (amount === undefined || amount === null) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'vaultRequestRedeem: amount is required');
+    }
+    validateAmountPrecision(amount);
     try {
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(target))?.[0];
         const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
@@ -340,13 +473,10 @@ async function vaultRequestRedeem(signer, options) {
             decimals = Number(await receiptContract.decimals());
             const normalizedAmt = (0, core_1.toNormalizedBn)(amount, decimals);
             const allowance = await receiptContract.allowance(wallet, target);
-            if (safeBigInt(allowance) < BigInt(normalizedAmt.raw)) {
-                const approveTx = await receiptContract
-                    .connect(signer)
-                    .approve(target, normalizedAmt.raw);
-                if (wait)
-                    await safeWaitForTx(approveTx);
-                core_1.Logger.log.info('approve:receipt_token:tx_hash', approveTx?.hash);
+            if (safeBigInt(allowance, 'vaultRequestRedeem:allowance') <
+                BigInt(normalizedAmt.raw)) {
+                const { hash: approveHash } = await safeSendTx(() => receiptContract.connect(signer).approve(target, normalizedAmt.raw), signer, true);
+                core_1.Logger.log.info('approve:receipt_token:tx_hash', approveHash);
             }
             poolContract = vaultContract;
         }
@@ -399,8 +529,10 @@ async function vaultRequestRedeem(signer, options) {
             core_1.Logger.log.warn('requestRedeem:nonce-fallback', { hash: recovered });
             return recovered;
         }
+        if (e instanceof core_1.AugustSDKError)
+            throw e;
         core_1.Logger.log.error('requestRedeem', e, { target, amount });
-        throw new Error(`Request redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+        throw new core_1.AugustSDKError('UNKNOWN', `Request redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, amount } });
     }
 }
 async function vaultRedeem(signer, options) {
@@ -409,32 +541,46 @@ async function vaultRedeem(signer, options) {
         (0, core_1.checkAddress)(wallet, console, 'wallet'),
         (0, core_1.checkAddress)(target, console),
     ];
-    if (!(goodWallet && goodPool && year && day && month && receiverIndex))
-        return;
+    if (!goodWallet || !goodPool) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `vaultRedeem: invalid ${!goodWallet ? 'wallet' : 'target'} address`);
+    }
+    if (!year || !month || !day || !receiverIndex) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'vaultRedeem: year, month, day, and receiverIndex are required');
+    }
     try {
         const poolContract = (0, core_1.createContract)({
             address: target,
             provider: signer,
             abi: abis_1.ABI_LENDING_POOLS,
         });
-        const redeemTx = await poolContract
+        const { hash: redeemHash } = await safeSendTx(() => poolContract
             .connect(signer)
-            .redeem(year, month, day, receiverIndex, wallet);
-        if (wait)
-            await safeWaitForTx(redeemTx);
-        core_1.Logger.log.info('redeem:tx_hash', redeemTx?.hash);
-        return redeemTx?.hash;
+            .redeem(year, month, day, receiverIndex, wallet), signer, wait);
+        core_1.Logger.log.info('redeem:tx_hash', redeemHash);
+        return redeemHash;
     }
     catch (e) {
+        const recovered = await tryRecoverTxHash(e, signer, wait);
+        if (recovered) {
+            core_1.Logger.log.warn('redeem:nonce-fallback', { hash: recovered });
+            return recovered;
+        }
+        if (e instanceof core_1.AugustSDKError)
+            throw e;
         core_1.Logger.log.error('redeem', e, { target, year, month, day, receiverIndex });
-        throw new Error(`Redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+        throw new core_1.AugustSDKError('UNKNOWN', `Redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, year, month, day, receiverIndex } });
     }
 }
 async function depositNative(signer, options) {
     const { wrapperAddress, receiver, amount, wait } = options;
     const goodWrapper = (0, core_1.checkAddress)(wrapperAddress, console, 'contract');
-    if (!goodWrapper || !amount)
-        return;
+    if (!goodWrapper) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', 'depositNative: invalid wrapper address');
+    }
+    if (amount === undefined || amount === null) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'depositNative: amount is required');
+    }
+    validateAmountPrecision(amount);
     try {
         const wrapperContract = (0, core_1.createContract)({
             address: wrapperAddress,
@@ -450,8 +596,9 @@ async function depositNative(signer, options) {
         const connectedContract = wrapperContract.connect(signer);
         if (receiver) {
             const goodReceiver = (0, core_1.checkAddress)(receiver, console, 'wallet');
-            if (!goodReceiver)
-                return;
+            if (!goodReceiver) {
+                throw new core_1.AugustValidationError('INVALID_ADDRESS', 'depositNative: invalid receiver address');
+            }
             const depositNativeWithReceiver = connectedContract.getFunction('depositNative(address)');
             depositTx = await depositNativeWithReceiver(receiver, {
                 value: amountBigInt,
@@ -474,8 +621,10 @@ async function depositNative(signer, options) {
             core_1.Logger.log.warn('depositNative:nonce-fallback', { hash: recovered });
             return recovered;
         }
+        if (e instanceof core_1.AugustSDKError)
+            throw e;
         core_1.Logger.log.error('depositNative', e, { wrapperAddress, receiver, amount });
-        throw new Error(`Deposit native failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+        throw new core_1.AugustSDKError('UNKNOWN', `Deposit native failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { wrapperAddress, receiver, amount } });
     }
 }
 async function rwaRedeemAsset(signer, options) {
@@ -483,27 +632,38 @@ async function rwaRedeemAsset(signer, options) {
     const goodTarget = (0, core_1.checkAddress)(target, console, 'contract');
     const goodAsset = (0, core_1.checkAddress)(asset, console, 'contract');
     const goodWallet = (0, core_1.checkAddress)(wallet, console, 'wallet');
-    if (!goodTarget || !goodAsset || !goodWallet)
-        return;
+    if (!goodTarget || !goodAsset || !goodWallet) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `rwaRedeemAsset: invalid ${!goodTarget ? 'target' : !goodAsset ? 'asset' : 'wallet'} address`);
+    }
+    validateAmountPrecision(amount);
+    validateAmountPrecision(minOut);
     try {
         const subaccountContract = (0, core_1.createContract)({
             address: target,
             provider: signer,
             abi: abis_1.RWA_REDEEM_SUBACCOUNT,
         });
-        if (!subaccountContract)
-            return;
+        if (!subaccountContract) {
+            throw new Error(`rwaRedeemAsset: failed to instantiate subaccount contract at ${target}`);
+        }
         const normalizedAmt = (0, core_1.toNormalizedBn)(amount, decimals);
         const normalizedMinOut = (0, core_1.toNormalizedBn)(minOut, outputDecimals);
-        const tx = await subaccountContract.redeemAsset(asset, BigInt(normalizedAmt.raw), BigInt(normalizedMinOut.raw));
-        if (wait)
-            await safeWaitForTx(tx);
-        core_1.Logger.log.info('rwaRedeemAsset:tx_hash', tx?.hash);
-        return tx?.hash;
+        const { hash: redeemHash } = await safeSendTx(() => subaccountContract
+            .connect(signer)
+            .redeemAsset(asset, BigInt(normalizedAmt.raw), BigInt(normalizedMinOut.raw)), signer, wait);
+        core_1.Logger.log.info('rwaRedeemAsset:tx_hash', redeemHash);
+        return redeemHash;
     }
     catch (e) {
+        const recovered = await tryRecoverTxHash(e, signer, wait);
+        if (recovered) {
+            core_1.Logger.log.warn('rwaRedeemAsset:nonce-fallback', { hash: recovered });
+            return recovered;
+        }
+        if (e instanceof core_1.AugustSDKError)
+            throw e;
         core_1.Logger.log.error('rwaRedeemAsset', e, { target, asset, amount, minOut });
-        throw new Error(`RWA redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+        throw new core_1.AugustSDKError('UNKNOWN', `RWA redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, asset, amount, minOut } });
     }
 }
 //# sourceMappingURL=write.actions.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augustdigital/sdk",
-  "version": "6.0.1",
+  "version": "7.0.0",
   "main": "lib/index.js",
   "keywords": [
     "augustdigital",
@@ -38,6 +38,7 @@
   "dependencies": {
     "@coral-xyz/anchor": "^0.31.1",
     "@sentry/browser": "^8.0.0",
+    "@sentry/node": "^8.0.0",
     "@solana/spl-token": "^0.4.14",
     "@solana/wallet-adapter-base": "^0.9.27",
     "@solana/web3.js": "^1.98.4",
@@ -70,6 +71,7 @@
     "test:jest": "jest",
     "test:jest:watch": "jest --watch",
     "test:jest:coverage": "jest --coverage",
+    "test:forknet": "node tests/forknet/run.mjs",
     "clean": "rm -rf ./lib",
     "format": "eslint . --fix",
     "lint-sdk": "lint-staged",