@augustdigital/sdk 8.19.0 → 8.21.0

package/lib/adapters/solana/vault.actions.js

@@ -49,18 +49,114 @@ function describeSolanaError(e) {
         ? str
         : REASONLESS_SOLANA_ERROR;
 }
+/**
+ * Pick which token account to hand the vault program for a given mint, and
+ * describe how to create it when the user has none.
+ *
+ * The vault program constrains these accounts by `token::mint` +
+ * `token::authority` (not `associated_token::…`), so any account the signer
+ * owns qualifies. We therefore keep an existing account when there is one —
+ * that is where the user's balance already lives — and fall back to the
+ * associated token account otherwise.
+ *
+ * Two deliberate choices:
+ *
+ * - **The create is returned, not sent.** Prepended to the deposit/redeem via
+ *   `.preInstructions()` it is atomic with the transfer, so there is no window
+ *   in which the vault instruction can reference an account that has not
+ *   landed. Sent as its own transaction — as this module used to — it raced
+ *   its own confirmation. Observed in production (AUGUST-7221, 2026-08-11):
+ *   a deposit failed with `Simulation failed … Logs: []` while the share-ATA
+ *   create was still in flight, then succeeded 17s later on retry. The empty
+ *   log array means the transaction never reached program execution, so there
+ *   was nothing on-chain to debug from.
+ * - **Idempotent.** `createAssociatedTokenAccountIdempotentInstruction` is a
+ *   no-op when the account already exists, so a concurrent create — another
+ *   tab, a wallet's auto-provisioning — cannot turn into an
+ *   `SystemError::AccountAlreadyInUse` ("already in use") failure between our
+ *   read and our submit.
+ *
+ * Which account wins when several exist is decided by
+ * {@link selectRichestTokenAccount} — the same rule every balance *read* in
+ * this adapter uses, so the account a UI reports and the account a transfer
+ * names are never different accounts.
+ *
+ * Classic SPL Token only: the ATA is derived under `TOKEN_PROGRAM_ID`, matching
+ * the `tokenProgram` both handlers pass, even though the program's
+ * `TokenInterface` would also accept Token-2022.
+ *
+ * @param owner - Wallet that owns the account and pays rent for any creation.
+ * @throws AugustSDKError when a candidate account's balance cannot be read
+ *   (propagated from the shared selector), and `TokenOwnerOffCurveError` when
+ *   `owner` is off-curve and an ATA has to be derived.
+ */
+async function resolveUserTokenAccount({ connection, owner, mint, }) {
+    const existing = await connection.getParsedTokenAccountsByOwner(owner, {
+        mint,
+    });
+    const richest = (0, utils_1.selectRichestTokenAccount)(existing.value);
+    if (richest)
+        return {
+            address: richest.pubkey,
+            balance: richest.amount,
+            frozen: richest.frozen,
+        };
+    const ata = await (0, spl_token_1.getAssociatedTokenAddress)(mint, owner);
+    return {
+        address: ata,
+        balance: BigInt(0),
+        frozen: false,
+        createIx: (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, // payer
+        ata, // associated token account
+        owner, // owner
+        mint),
+    };
+}
+/**
+ * Resolve the two token accounts a vault instruction needs, concurrently.
+ *
+ * The lookups are independent, so running them in sequence doubles the
+ * round-trip latency on the hot path for no benefit — both results are needed
+ * before anything is submitted either way.
+ *
+ * Rejections are surfaced in argument order rather than in whichever order the
+ * RPC happened to fail, so the error a user sees does not depend on network
+ * timing. `Promise.all` would reject with whichever call failed *first*, which
+ * on a malformed RPC response (both lookups throwing) would name a different
+ * account run to run.
+ *
+ * @param mints - `[first, second]`; the returned tuple matches this order.
+ */
+async function resolveUserTokenAccountPair({ connection, owner, mints, }) {
+    const settled = await Promise.allSettled(mints.map((mint) => resolveUserTokenAccount({ connection, owner, mint })));
+    const resolved = settled.map((outcome) => {
+        if (outcome.status === 'rejected')
+            throw outcome.reason;
+        return outcome.value;
+    });
+    return [resolved[0], resolved[1]];
+}
 /**
  * Deposit funds into a Solana August vault and mint share tokens.
  *
  * @param depositAmount  `bigint` is treated as raw on-chain units (preferred
  *   — no JS-float round-trip). `number` is treated as a UI amount and
  *   scaled by the deposit mint's decimals via {@link uiAmountToRawBn}.
- * @throws AugustValidationError on missing wallet/programId or invalid amount.
+ * @throws AugustValidationError on missing wallet/programId or invalid amount,
+ *   or when the wallet's deposit-mint balance is below `depositAmount`.
+ * @throws AugustSDKError when a candidate token account's balance cannot be
+ *   read, or wrapping any downstream failure (`cause` preserved).
+ * @remarks **Side effects.** Submits exactly one transaction, signed by the
+ *   provider's wallet. When the wallet has no share account, that transaction
+ *   also creates one, and `publicKey` pays its rent — roughly 0.00204 SOL,
+ *   non-refundable while the account stays open — on top of the network fee.
+ *   Callers should ensure the wallet holds enough SOL for both before
+ *   prompting the user to sign.
  * @remarks The on-chain `deposit` instruction has no `min_shares_out`
  *   parameter; slippage cannot be enforced on-chain until the program ships
  *   that argument.
  */
-async function handleSolanaDeposit({ provider, connection, network = constants_1.fallbackNetwork, vaultProgramId, vaultAddress, depositAmount, publicKey, sendTransaction, idl, }) {
+async function handleSolanaDeposit({ provider, connection, network = constants_1.fallbackNetwork, vaultProgramId, vaultAddress, depositAmount, publicKey, idl, }) {
     try {
         if (!publicKey)
             throw new core_1.AugustValidationError('INVALID_INPUT', 'handleSolanaDeposit: wallet not connected');
@@ -119,50 +215,70 @@ async function handleSolanaDeposit({ provider, connection, network = constants_1
             }
             depositAmountRaw = (0, utils_1.uiAmountToRawBn)(depositAmount, decimals);
         }
-        // Find user's token accounts
-        const userTokenAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
-            mint: _depositMint,
-        });
-        core_1.Logger.log.info('handleSolanaDeposit', 'User token accounts', userTokenAccounts);
-        const userShareAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
-            mint: shareMintAddr,
+        // Re-check *after* scaling. The guard above tests the caller's number, but
+        // a positive UI amount below one raw unit (1e-7 into a 6-decimal mint)
+        // truncates to zero here. Zero would then pass the balance gate below
+        // (`0n < 0n` is false) and submit a no-op transfer — from an account that
+        // may not even exist, since a zero balance is also what an absent account
+        // reports.
+        if (depositAmountRaw.lten(0)) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `Deposit amount is too small: ${depositAmount} is below one raw unit ` +
+                `of a ${decimals}-decimal mint.`);
+        }
+        // Match whatever this connection *reads* at. A `Connection` built without
+        // a commitment omits the parameter, so its reads take the RPC's default —
+        // `finalized`. Confirming writes at `confirmed` there would put reads
+        // behind writes again, which is the mismatch this whole change removes.
+        // `SolanaAdapter` always sets one explicitly, so this fallback only
+        // applies to callers reaching these handlers directly via `Solana.actions`.
+        const txCommitment = connection.commitment ?? 'finalized';
+        // `depositAccount` funds the transfer; `shareAccount` receives the minted
+        // shares. Independent lookups, so they run concurrently — but the guards
+        // below stay in a fixed order so the first problem a user hits is always
+        // reported the same way.
+        const [depositAccount, shareAccount] = await resolveUserTokenAccountPair({
+            connection,
+            owner: _publicKey,
+            mints: [_depositMint, shareMintAddr],
         });
-        core_1.Logger.log.info('handleSolanaDeposit', 'User share accounts', userShareAccounts);
-        if (userTokenAccounts.value.length === 0) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', 'No token account found for deposit mint. Please create a token account first.');
+        // Gate on the balance, not on whether an account exists: an empty leftover
+        // account is a real state, and letting it through only trades this error
+        // for an insufficient-funds revert the user pays a signature to discover.
+        // The balance is already in hand from the lookup, so this costs no extra
+        // RPC.
+        if (depositAccount.frozen) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Your token account for the deposit mint is frozen by the token issuer, ' +
+                'so the deposit cannot be transferred out of it.');
         }
-        let senderShareAccount;
-        if (userShareAccounts.value.length === 0) {
-            core_1.Logger.log.info('handleSolanaDeposit', 'Creating share account');
-            // Create share account if it doesn't exist
-            senderShareAccount = await (0, spl_token_1.getAssociatedTokenAddress)(shareMintAddr, _publicKey);
-            core_1.Logger.log.info('handleSolanaDeposit', 'Sender share account', senderShareAccount.toBase58());
-            // Create the associated token account
-            const createAtaIx = (0, spl_token_1.createAssociatedTokenAccountInstruction)(_publicKey, // payer
-            senderShareAccount, // associated token account
-            _publicKey, // owner
-            shareMintAddr);
-            core_1.Logger.log.info('handleSolanaDeposit', 'Create ATA Ix', createAtaIx.programId.toBase58());
-            const transaction = new web3_js_1.Transaction().add(createAtaIx);
-            const signature = await sendTransaction(transaction, connection);
-            core_1.Logger.log.info('handleSolanaDeposit', 'Created share account:', signature.toString());
+        if (depositAccount.balance < BigInt(depositAmountRaw.toString())) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `Insufficient balance to deposit: this wallet holds ${depositAccount.balance} ` +
+                `raw units of the deposit mint, and the deposit requires ${depositAmountRaw.toString()}.`);
         }
-        else {
-            senderShareAccount = userShareAccounts.value[0]?.pubkey;
+        const senderTokenAccount = depositAccount.address;
+        // A missing share account is routine — every first-time depositor starts
+        // here, as does anyone whose account was closed after redeeming their full
+        // balance — so it is created inline rather than rejecting the deposit.
+        // Minting into a *frozen* one fails just as transferring out of one does,
+        // so this destination needs the same guard as the funding account above.
+        if (shareAccount.frozen) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Your share account is frozen by the token issuer, so it cannot ' +
+                'receive the shares this deposit would mint.');
         }
-        const senderTokenAccount = userTokenAccounts.value[0]?.pubkey;
-        core_1.Logger.log.info('handleSolanaDeposit', 'Sender token account', senderTokenAccount);
+        const senderShareAccount = shareAccount.address;
+        const preInstructions = shareAccount.createIx
+            ? [shareAccount.createIx]
+            : [];
+        core_1.Logger.log.info('handleSolanaDeposit', 'Sender token account', senderTokenAccount.toBase58());
+        core_1.Logger.log.info('handleSolanaDeposit', shareAccount.createIx
+            ? 'Sender share account (created in this tx)'
+            : 'Sender share account (existing)', senderShareAccount.toBase58());
         core_1.Logger.log.info('handleSolanaDeposit', '\n\nDeposit TX Params:\n');
         core_1.Logger.log.info('handleSolanaDeposit', 'Program', depositAmountRaw);
         core_1.Logger.log.info('handleSolanaDeposit', 'Vault state PDA', vaultStatePda.toBase58());
         core_1.Logger.log.info('handleSolanaDeposit', 'Vault token ATA PDA', vaultTokenAtaPda.toBase58());
-        core_1.Logger.log.info('handleSolanaDeposit', 'Sender token account', senderTokenAccount?.toBase58());
-        core_1.Logger.log.info('handleSolanaDeposit', 'Sender share account', senderShareAccount?.toBase58());
         core_1.Logger.log.info('handleSolanaDeposit', 'Share mint', shareMintAddr.toBase58());
         core_1.Logger.log.info('handleSolanaDeposit', 'Deposit mint', _depositMint?.toBase58());
         core_1.Logger.log.info('handleSolanaDeposit', 'Signer', _publicKey.toBase58());
-        // Get a fresh blockhash to avoid "Blockhash not found" errors
-        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
         // TODO(slippage): pass `min_shares_out` here when the program ships it.
         const tx = await program.methods
             .deposit(depositAmountRaw)
@@ -172,21 +288,25 @@ async function handleSolanaDeposit({ provider, connection, network = constants_1
             senderTokenAccount,
             senderShareAccount,
             shareMint: shareMintAddr,
-            depositMint: depositMint,
-            signer: publicKey,
+            depositMint: _depositMint,
+            signer: _publicKey,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         })
+            .preInstructions(preInstructions)
+            // `.rpc()` builds, signs, submits and confirms in one step. The extra
+            // `getLatestBlockhash` + `confirmTransaction` this module used to run
+            // afterwards re-confirmed an already-confirmed signature against a
+            // blockhash the transaction never carried.
+            //
+            // Commitment is taken from the same `Connection` every read in this
+            // adapter uses, so a caller who asks for 'finalized' gets it on both
+            // sides rather than finalized reads racing confirmed writes.
             .rpc({
             skipPreflight: false,
-            preflightCommitment: 'confirmed',
+            preflightCommitment: txCommitment,
+            commitment: txCommitment,
         });
         core_1.Logger.log.info('handleSolanaDeposit', 'Deposit successful:', tx);
-        // Wait for confirmation with the blockhash we used
-        await connection.confirmTransaction({
-            signature: tx,
-            blockhash,
-            lastValidBlockHeight,
-        }, 'confirmed');
         return tx;
     }
     catch (e) {
@@ -216,9 +336,18 @@ async function handleSolanaDeposit({ provider, connection, network = constants_1
  * @param redeemShares  `bigint` is treated as raw share-token units;
  *   `number` is treated as a UI amount. See {@link handleSolanaDeposit} for
  *   the same caveat about the missing on-chain slippage guard.
- * @throws AugustValidationError on missing wallet/programId or invalid amount.
+ * @throws AugustValidationError on missing wallet/programId or invalid amount,
+ *   or when the wallet holds fewer shares than `redeemShares`.
+ * @throws AugustSDKError when a candidate token account's balance cannot be
+ *   read, or wrapping any downstream failure (`cause` preserved).
+ * @remarks **Side effects.** Submits exactly one transaction, signed by the
+ *   provider's wallet. That transaction also creates the payout account when
+ *   the wallet has none, and the vault's fee-recipient account when *it* has
+ *   none — `publicKey` pays rent for both, roughly 0.00204 SOL each and
+ *   non-refundable, on top of the network fee. Callers should ensure the
+ *   wallet holds enough SOL for all of it before prompting the user to sign.
  */
-async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultAddress, publicKey, redeemShares, sendTransaction, idl, }) {
+async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultAddress, publicKey, redeemShares, idl, }) {
     try {
         if (!publicKey)
             throw new core_1.AugustValidationError('INVALID_INPUT', 'handleSolanaRedeem: wallet not connected');
@@ -276,21 +405,48 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
             }
             redeemSharesRaw = (0, utils_1.uiAmountToRawBn)(redeemShares, shareDecimals);
         }
-        // Find user's token accounts
-        const userTokenAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
-            mint: _depositMint,
-        });
-        const userShareAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
-            mint: shareMintAddr,
+        // See `handleSolanaDeposit` — a positive UI amount can truncate to zero,
+        // which would pass the share-balance gate below and burn nothing.
+        if (redeemSharesRaw.lten(0)) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `Redemption amount is too small: ${redeemShares} is below one raw unit ` +
+                `of a ${shareDecimals}-decimal share mint.`);
+        }
+        // Match whatever this connection *reads* at. A `Connection` built without
+        // a commitment omits the parameter, so its reads take the RPC's default —
+        // `finalized`. Confirming writes at `confirmed` there would put reads
+        // behind writes again, which is the mismatch this whole change removes.
+        // `SolanaAdapter` always sets one explicitly, so this fallback only
+        // applies to callers reaching these handlers directly via `Solana.actions`.
+        const txCommitment = connection.commitment ?? 'finalized';
+        // `shareAccount` is burned from; `payoutAccount` receives the underlying.
+        // Independent lookups, so they run concurrently — guards stay ordered.
+        const [shareAccount, payoutAccount] = await resolveUserTokenAccountPair({
+            connection,
+            owner: _publicKey,
+            mints: [shareMintAddr, _depositMint],
         });
-        if (userTokenAccounts.value.length === 0) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', 'No token account found for deposit mint. Please create a token account first.');
+        // Gated on balance for the same reason as the deposit's funding account.
+        if (shareAccount.frozen) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Your share account is frozen by the token issuer, so these shares ' +
+                'cannot be redeemed.');
+        }
+        if (shareAccount.balance < BigInt(redeemSharesRaw.toString())) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `Insufficient shares to redeem: this wallet holds ${shareAccount.balance} ` +
+                `raw share units, and the redemption requires ${redeemSharesRaw.toString()}.`);
         }
-        if (userShareAccounts.value.length === 0) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', 'No share account found. You need to deposit first to get shares before you can redeem.');
+        const senderShareAccount = shareAccount.address;
+        // Redeeming is precisely how a holder first receives the deposit mint, so
+        // requiring the payout account to pre-exist (as this module used to) left
+        // shares unredeemable through this SDK for everyone who acquired them any
+        // way other than depositing from this same wallet — a transfer, an
+        // airdrop, a market buy — as well as any depositor who later closed their
+        // deposit-mint account. A frozen account cannot receive either, so the
+        // payout would revert.
+        if (payoutAccount.frozen) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Your token account for the deposit mint is frozen by the token issuer, ' +
+                'so it cannot receive the redemption proceeds.');
         }
-        const senderTokenAccount = userTokenAccounts?.value[0]?.pubkey;
-        const senderShareAccount = userShareAccounts?.value[0]?.pubkey;
+        const senderTokenAccount = payoutAccount.address;
         // Get the fee recipient from vault state
         const readOnlyProvider = utils_1.SolanaUtils.getReadOnlyProvider({ connection });
         const readOnlyProgram = utils_1.SolanaUtils.getProgram({
@@ -301,22 +457,20 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
         const vaultStateData = await readOnlyProgram.account.vaultState.fetch(vaultStatePda);
         // Get the fee recipient's token account
         const feeRecipientTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(_depositMint, vaultStateData.feeRecipient);
-        // Check if the fee recipient token account exists, if not create it
-        const feeRecipientAccountInfo = await connection.getAccountInfo(feeRecipientTokenAccount);
-        if (!feeRecipientAccountInfo) {
-            const createFeeRecipientAtaIx = (0, spl_token_1.createAssociatedTokenAccountInstruction)(_publicKey, // payer (user pays for the account creation)
+        // Every account this handler might have to create is created in the same
+        // transaction that uses it. The fee recipient's ATA is created
+        // unconditionally: the idempotent instruction is a no-op when the account
+        // already exists (costing the user nothing), which buys us one fewer RPC
+        // round trip and removes the read-then-create window entirely. The user
+        // pays the rent when it is genuinely absent, as before.
+        const preInstructions = [
+            (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(_publicKey, // payer (user pays for the account creation)
             feeRecipientTokenAccount, // associated token account
             vaultStateData.feeRecipient, // owner (the actual fee recipient)
-            _depositMint);
-            const createAccountTx = new web3_js_1.Transaction().add(createFeeRecipientAtaIx);
-            const createAccountSignature = await sendTransaction(createAccountTx, connection);
-            core_1.Logger.log.info('handleSolanaRedeem', 'Fee recipient token account created:', createAccountSignature);
-            // Wait a moment for the account to be created
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-        }
-        else {
-            core_1.Logger.log.info('handleSolanaRedeem', 'Fee recipient token account already exists');
-        }
+            _depositMint),
+        ];
+        if (payoutAccount.createIx)
+            preInstructions.push(payoutAccount.createIx);
         core_1.Logger.log.info('handleSolanaRedeem', '\n\nRedeem TX Params:\n');
         core_1.Logger.log.info('handleSolanaRedeem', 'Redeem shares (UI):', redeemShares);
         core_1.Logger.log.info('handleSolanaRedeem', 'Redeem shares (raw):', redeemSharesRaw);
@@ -329,8 +483,6 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
         core_1.Logger.log.info('handleSolanaRedeem', 'Share mint:', shareMintAddr.toBase58());
         core_1.Logger.log.info('handleSolanaRedeem', 'Deposit mint:', _depositMint?.toBase58());
         core_1.Logger.log.info('handleSolanaRedeem', 'Signer:', _publicKey.toBase58());
-        // Get a fresh blockhash to avoid "Blockhash not found" errors
-        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
         const tx = await program.methods
             .redeem(redeemSharesRaw)
             .accounts({
@@ -344,17 +496,15 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
             signer: _publicKey,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         })
+            .preInstructions(preInstructions)
+            // See `handleSolanaDeposit` for why `.rpc()` owns the confirmation and
+            // why the commitment comes from the connection.
             .rpc({
             skipPreflight: false,
-            preflightCommitment: 'confirmed',
+            preflightCommitment: txCommitment,
+            commitment: txCommitment,
         });
         core_1.Logger.log.info('handleSolanaRedeem', 'Redeem successful:', tx);
-        // Wait for confirmation with the blockhash we used
-        await connection.confirmTransaction({
-            signature: tx,
-            blockhash,
-            lastValidBlockHeight,
-        }, 'confirmed');
         return tx;
     }
     catch (e) {

package/lib/adapters/sui/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const SUI_CHAIN_ID = 101;
+export { SUI_CHAIN_ID } from '../../core/constants/web3';
 export declare const EMBER_API_BASE_URL = "https://vaults.api.sui-prod.bluefin.io/api/v1/vaults";
 export declare const EMBER_ENDPOINTS: {
     readonly VAULTS: "/";

package/lib/adapters/sui/constants.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ALLOWED_SUI_VAULT_ADDRESSES = exports.EMBER_DEFAULTS = exports.EMBER_ENDPOINTS = exports.EMBER_API_BASE_URL = exports.SUI_CHAIN_ID = void 0;
-exports.SUI_CHAIN_ID = 101;
+// Canonical definition lives in `core/constants/web3.ts` so `core/` can
+// recognise the Sui chain ID without importing the adapter layer. Re-exported
+// here to keep `adapters/sui/constants` import sites (and the published API)
+// unchanged.
+var web3_1 = require("../../core/constants/web3");
+Object.defineProperty(exports, "SUI_CHAIN_ID", { enumerable: true, get: function () { return web3_1.SUI_CHAIN_ID; } });
 exports.EMBER_API_BASE_URL = 'https://vaults.api.sui-prod.bluefin.io/api/v1/vaults';
 exports.EMBER_ENDPOINTS = {
     VAULTS: '/',

package/lib/core/analytics/sentry.d.ts

@@ -1,6 +1,13 @@
 import type * as Sentry from '@sentry/browser';
 import type { IEnv } from '../../types';
 import type { IAnalyticsConfig } from './types';
+/**
+ * Clear the error dedupe bookkeeping. Test-only — the rate limiter is process
+ * lifetime state and would otherwise leak between test cases.
+ *
+ * @internal
+ */
+export declare function resetErrorDedupe(): void;
 /**
  * Initialize Sentry with SDK-specific configuration. Idempotent: re-calls
  * only refresh user identity and the cached API-key hash.