@augustdigital/sdk 8.17.0 → 8.19.0

package/lib/modules/vaults/getters.js

@@ -2133,8 +2133,10 @@ async function getVaultUserLifetimePnl({ vault, wallet, options, }) {
         });
         let sharePriceRaw = BigInt(0);
         try {
+            // Retried on transport blips only (bounded, no fallback); a vault that
+            // genuinely has no `lpTokenAddress()` still throws into the catch below.
             const lpTokenAddress = version === 'evm-2'
-                ? (await vaultContract.lpTokenAddress())
+                ? await (0, core_1.getReceiptTokenAddressOrThrow)(provider, vault, 'getVaultUserLifetimePnl:receiptToken')
                 : vault;
             let currentShares = BigInt(0);
             if (version === 'evm-2') {
@@ -2648,7 +2650,9 @@ async function getPreviewRedemption({ vault, sharesAmount, options, }) {
                 abi: TokenizedVaultV2_1.ABI_TOKENIZED_VAULT_V2,
                 provider,
             });
-            const lpTokenAddress = (await contract.lpTokenAddress());
+            // Retried on transport blips only (bounded, no fallback); a misroute
+            // still surfaces the original error.
+            const lpTokenAddress = await (0, core_1.getReceiptTokenAddressOrThrow)(provider, vault, 'getPreviewRedemption:receiptToken');
             const lpTokenContract = (0, core_1.createContract)({
                 address: lpTokenAddress,
                 abi: abis_1.ABI_LENDING_POOL_V2,

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

@@ -81,7 +81,47 @@ export declare function resolveSpender(args: {
 export declare function validateAmountPrecision(amount: string | bigint | number): void;
 /** @internal */
 export declare function isNonceParsing(error: unknown): boolean;
-/** @internal */
+/**
+ * Await a broadcast transaction's receipt, surviving both malformed-nonce RPCs
+ * and transient transport faults while still reporting genuine on-chain
+ * failures.
+ *
+ * `tx.wait()` is tried first because it preserves ethers' replacement-tx
+ * detection and revert checks. Two recoverable failure modes are handled:
+ *
+ * 1. **Malformed nonce** ({@link isNonceParsing}) — Monad-style RPCs return
+ *    `nonce: "undefined"` on the pending tx and ethers throws while parsing.
+ *    One direct `provider.waitForTransaction()` recovers it (unchanged
+ *    behaviour).
+ * 2. **Transient transport fault** ({@link isRetryableRpcError}) — the provider
+ *    hiccups while polling `eth_getTransactionReceipt` and ethers surfaces
+ *    `could not coalesce error (… "code": -32603 …)`. This used to propagate
+ *    and make every write path report a **successfully mined** transaction as
+ *    failed, driving users to retry into `ERC20InsufficientBalance`. The hash
+ *    is already on the wire and receipt polling is idempotent, so we re-poll
+ *    with bounded exponential backoff instead of rethrowing.
+ *
+ * Everything else — notably a real revert — is rethrown untouched.
+ *
+ * Every error this function throws is stamped by {@link markBroadcast}: by the
+ * time `tx.wait()` can fail, the transaction is already on the wire, so the
+ * caller must never report it as "never sent". See
+ * {@link localTxBroadcastContext} for how that reaches
+ * `AugustSDKError.context`.
+ *
+ * @param tx - The broadcast transaction response to await.
+ * @returns The mined receipt (never `null` on the fallback paths; `tx.wait()`
+ *   itself may return `null` when the caller configured 0 confirmations).
+ * @throws {Error} `Transaction <hash> reverted on-chain` when the receipt
+ *   reports `status === 0`. Marked `confirmationUnknown: false` — the chain
+ *   answered.
+ * @throws {Error} `Transaction <hash> was not confirmed within <n>s` when the
+ *   overall wait times out with no receipt. Marked
+ *   `confirmationUnknown: true`.
+ * @throws The underlying transport error once receipt-poll retries are
+ *   exhausted, marked `confirmationUnknown: true`.
+ * @internal
+ */
 export declare function safeWaitForTx(tx: TransactionResponse): Promise<import("ethers").TransactionReceipt>;
 /**
  * Wraps an ethers contract call that returns a TransactionResponse.