@piprail/sdk 3.0.0 → 3.1.0

package/dist/index.js

@@ -401,6 +401,11 @@ function resolveChain(input, rpcUrlOverride) {
     }
     return { chain: input, chainId: input.id, rpcUrl: rpcUrl2, tokens: knownTokensForId(input.id) };
   }
+  if (!Number.isSafeInteger(input.id) || input.id <= 0) {
+    throw new Error(
+      `resolveChain: chain id must be a positive safe integer (EIP-155), got ${String(input.id)}.`
+    );
+  }
   const rpcUrl = rpcUrlOverride ?? input.rpcUrl;
   if (!rpcUrl) {
     throw new Error(`resolveChain: chain ${input.id} needs an rpcUrl.`);
@@ -574,8 +579,25 @@ async function quoteEvmSwap(p) {
   } catch {
     return null;
   }
-  const real = await route(needIn);
-  const summary = real?.data?.routeSummary;
+  const MAX_REFINEMENTS = 3;
+  let real = await route(needIn);
+  let summary = real?.data?.routeSummary;
+  for (let attempt = 0; attempt < MAX_REFINEMENTS; attempt++) {
+    if (!summary?.amountOut) break;
+    let out;
+    try {
+      out = BigInt(summary.amountOut);
+    } catch {
+      return null;
+    }
+    if (out >= p.wantAmount) break;
+    if (out <= 0n) return null;
+    const next = applySlippage((needIn * p.wantAmount + out - 1n) / out, p.slippageBps);
+    if (next <= needIn) break;
+    needIn = next;
+    real = await route(needIn);
+    summary = real?.data?.routeSummary;
+  }
   if (!summary?.amountOut || !real?.data?.routerAddress) return null;
   try {
     if (BigInt(summary.amountOut) < p.wantAmount) return null;
@@ -2440,7 +2462,7 @@ var loaders = {
   solana: async () => {
     let mod;
     try {
-      mod = await import("./solana-O6Q6QILH.js");
+      mod = await import("./solana-WRXL54MR.js");
     } catch (cause) {
       throw new MissingDriverError(
         `Solana selected, but its packages aren't installed. Run: npm install @solana/web3.js @solana/spl-token bs58`,
@@ -2464,7 +2486,7 @@ var loaders = {
   stellar: async () => {
     let mod;
     try {
-      mod = await import("./stellar-YF5LOJEM.js");
+      mod = await import("./stellar-YQLOIFDD.js");
     } catch (cause) {
       throw new MissingDriverError(
         `Stellar selected, but its package isn't installed. Run: npm install @stellar/stellar-sdk`,
@@ -2476,7 +2498,7 @@ var loaders = {
   xrpl: async () => {
     let mod;
     try {
-      mod = await import("./xrpl-GOVHMYYK.js");
+      mod = await import("./xrpl-5K444RGX.js");
     } catch (cause) {
       throw new MissingDriverError(
         `XRPL selected, but its package isn't installed. Run: npm install xrpl`,
@@ -2536,7 +2558,7 @@ var loaders = {
   algorand: async () => {
     let mod;
     try {
-      mod = await import("./algorand-HL57PQHE.js");
+      mod = await import("./algorand-KJ5XHSMT.js");
     } catch (cause) {
       throw new MissingDriverError(
         `Algorand selected, but its package isn't installed. Run: npm install algosdk`,
@@ -2846,8 +2868,39 @@ var SpendLedger = class {
     }
   }
   /** Running total (base units) already spent on this (network, asset). */
+  /*
+   * ── IN-FLIGHT RESERVATIONS ─────────────────────────────────────────────────────────
+   *
+   * A cap is read when a quote is priced and written when the payment settles, and a whole
+   * network round trip sits between the two. Without a reservation, N concurrent payments all
+   * price against the same "spent so far", all pass, and all settle: an agent with a 2.50 cap
+   * spends 4.00 and every individual check was correct. It is the same read-await-write shape
+   * that let one proof be redeemed N times, on the other side of the wire.
+   *
+   * A reservation is taken SYNCHRONOUSLY by the client before it pays, counts toward every
+   * total below while it is outstanding, and is released the moment the payment either settles
+   * (the real record replaces it) or fails (so a refused payment never consumes the leash).
+   */
+  pending = /* @__PURE__ */ new Map();
+  pendingSeq = 0;
+  /** Reserve budget for a payment about to be attempted. Returns the token to settle it with. */
+  reserve(network, asset, amountBase, decimals, denom) {
+    const token = `r${++this.pendingSeq}`;
+    const scaled = denom ? scaleToDenom(amountBase, decimals) ?? 0n : 0n;
+    this.pending.set(token, { network, asset, amountBase, denom: denom?.toUpperCase(), scaled, at: Date.now() });
+    return token;
+  }
+  /** Drop a reservation: the payment settled (its real record now counts) or it failed. */
+  release(token) {
+    if (token) this.pending.delete(token);
+  }
+  pendingFor(network, asset) {
+    let sum = 0n;
+    for (const p of this.pending.values()) if (p.network === network && p.asset === asset) sum += p.amountBase;
+    return sum;
+  }
   totalFor(network, asset) {
-    return this.buckets.get(keyFor(network, asset))?.total ?? 0n;
+    return (this.buckets.get(keyFor(network, asset))?.total ?? 0n) + this.pendingFor(network, asset);
   }
   /**
    * Running grand total for a DENOMINATION, scaled to {@link DENOM_PRECISION} (so
@@ -2856,11 +2909,14 @@ var SpendLedger = class {
    * `0n` for a denomination never spent on. Case-insensitive.
    */
   totalForDenom(denom) {
-    return this.denomTotals.get(denom.toUpperCase()) ?? 0n;
+    const key = denom.toUpperCase();
+    let pending = 0n;
+    for (const p of this.pending.values()) if (p.denom === key) pending += p.scaled;
+    return (this.denomTotals.get(key) ?? 0n) + pending;
   }
   /** Total number of settled payments (across every chain + token). Powers `maxPayments`. */
   count() {
-    return this.records.length;
+    return this.records.length + this.pending.size;
   }
   /** Mark a `warnAtFraction` threshold key as fired; returns `true` the FIRST time (so the
    *  caller emits the `budget-threshold` event once) and `false` thereafter. Shared across
@@ -2878,6 +2934,7 @@ var SpendLedger = class {
    */
   countSince(sinceMs) {
     let n = 0;
+    for (const p of this.pending.values()) if (p.at >= sinceMs) n += 1;
     for (const r of this.records) {
       const t = Date.parse(r.at);
       if (Number.isNaN(t) || t >= sinceMs) n += 1;
@@ -2893,6 +2950,9 @@ var SpendLedger = class {
    */
   totalSince(network, asset, sinceMs) {
     let sum = 0n;
+    for (const p of this.pending.values()) {
+      if (p.network === network && p.asset === asset && p.at >= sinceMs) sum += p.amountBase;
+    }
     for (const r of this.records) {
       if (r.network !== network || r.asset !== asset) continue;
       const t = Date.parse(r.at);
@@ -3303,6 +3363,32 @@ var PipRailClient = class {
     this.assertPolicyTimeOptions(opts.policy);
     this.assertPolicySpendControls(opts.policy);
     this.assertModeIsHonest(opts);
+    this.sealAuthority();
+  }
+  /**
+   * Pin the three authority accessors to THIS instance, non-writable and non-configurable.
+   *
+   * `paymentTools()` decides which tools a model is handed by calling `canAgentSell()` /
+   * `canAgentSwap()`, which read `mode()`. Those were plain prototype methods, so any code
+   * holding the client could reassign one — `client.mode = () => 'sovereign'` turned a
+   * budgeted client's eight tools into sovereign's fourteen.
+   *
+   * A MODEL could never do that (it sends JSON tool arguments; it does not hold the object),
+   * so this is not a path a model can walk. It is defence in depth for the case where a
+   * client passes through code that is not the operator's own: an agent framework, a plugin,
+   * some middleware that wraps or proxies objects. Authority is set once, by whoever
+   * provisioned the key, and nothing downstream gets to revise it.
+   */
+  sealAuthority() {
+    const mode = this.opts.mode ?? DEFAULT_AGENT_MODE;
+    const sovereign = mode === "sovereign";
+    for (const [name, fn] of [
+      ["mode", () => mode],
+      ["canAgentSell", () => sovereign],
+      ["canAgentSwap", () => sovereign]
+    ]) {
+      Object.defineProperty(this, name, { value: fn, writable: false, configurable: false, enumerable: false });
+    }
   }
   /**
    * Fail LOUDLY at construction on a malformed amount cap — a security boundary
@@ -4245,22 +4331,35 @@ var PipRailClient = class {
       quote = plan.best.quote;
     }
     this.safeEmit({ kind: "payment-required", challenge, accept });
-    await this.authorize(quote);
+    const reservation = await this.authorize(quote);
     if (accept.scheme === "upto") {
-      return this.payUptoRail(net, wallet, accept, url, init, quote);
+      try {
+        return await this.payUptoRail(net, wallet, accept, url, init, quote, reservation);
+      } finally {
+        this.ledger.release(reservation);
+      }
     }
     if (accept.scheme === "exact") {
-      return this.payExactRail(net, wallet, accept, url, init, quote, challenge.x402Version);
+      try {
+        return await this.payExactRail(net, wallet, accept, url, init, quote, challenge.x402Version, reservation);
+      } finally {
+        this.ledger.release(reservation);
+      }
     }
     if (accept.scheme !== "onchain-proof") {
+      this.ledger.release(reservation);
       throw new UnsupportedSchemeError(
         `internal: unrouted accept scheme '${accept.scheme}' reached the onchain-proof pay path.`
       );
     }
-    const { ref, confirmed } = await this.payAndConfirm(net, wallet, accept);
-    const response = await this.retryWithProof(url, init, accept, ref, confirmed);
-    this.recordSpend(quote, ref);
-    return response;
+    try {
+      const { ref, confirmed } = await this.payAndConfirm(net, wallet, accept);
+      const response = await this.retryWithProof(url, init, accept, ref, confirmed);
+      this.recordSpend(quote, ref, void 0, reservation);
+      return response;
+    } finally {
+      this.ledger.release(reservation);
+    }
   }
   /* ------------------------- internals ------------------------- */
   /**
@@ -4449,9 +4548,11 @@ var PipRailClient = class {
         shortfall.token = formatUnits(amount - bal.token, quote.decimals);
       }
     } else if (isNative) {
-      if (nativeKnown && bal.native < amount + fee) {
+      const spendable = bal.token ?? bal.native;
+      const spendableKnown = spendable != null;
+      if (spendableKnown && spendable < amount + fee) {
         blockers.push("INSUFFICIENT_TOKEN");
-        shortfall.token = formatUnits(amount + fee - bal.native, quote.decimals);
+        shortfall.token = formatUnits(amount + fee - spendable, quote.decimals);
       }
     } else {
       if (tokenKnown && bal.token < amount) {
@@ -4603,18 +4704,28 @@ var PipRailClient = class {
         quote
       });
     }
+    const reservation = this.ledger.reserve(
+      quote.network,
+      quote.asset,
+      BigInt(quote.amount),
+      quote.decimals,
+      denomOf(quote.symbol, quote.asset, this.opts.policy)
+    );
     const hook = this.opts.onBeforePay;
-    if (!hook) return;
+    if (!hook) return reservation;
     let approved;
     try {
       approved = await hook(quote);
     } catch (err) {
+      this.ledger.release(reservation);
       this.refuse("onBeforePay threw \u2014 refusing to pay.", { reasonCode: "APPROVAL", quote, cause: err });
     }
     if (!approved) {
+      this.ledger.release(reservation);
       const reason = `onBeforePay declined ${quote.amountFormatted} ${quote.symbol ?? ""}`.trimEnd() + ` on ${quote.network}.`;
       this.refuse(reason, { reasonCode: "APPROVAL", quote });
     }
+    return reservation;
   }
   /**
    * Refuse a payment BEFORE any send: emit BOTH the legacy `payment-failed` (so existing
@@ -4653,7 +4764,7 @@ var PipRailClient = class {
    *  spend (POL-1). So the cap-bearing `amountBase` is the MAX; the clamped actual is surfaced
    *  separately on `settledBase`/`settledFormatted` for transparency (it equals the receipt's
    *  amount). When absent (onchain-proof/exact) this is byte-identical to before. */
-  recordSpend(quote, ref, settledAmountBase) {
+  recordSpend(quote, ref, settledAmountBase, reservation) {
     const denom = denomOf(quote.symbol, quote.asset, this.opts.policy);
     const amountBase = quote.amount;
     const amountFormatted = quote.amountFormatted;
@@ -4684,6 +4795,7 @@ var PipRailClient = class {
       at: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.ledger.record(record, quote.decimals, denom);
+    this.ledger.release(reservation);
     const budget = this.budget();
     if (this.opts.onSpend) {
       try {
@@ -4855,7 +4967,7 @@ var PipRailClient = class {
    *   • a 200 whose SettleResponse says `success:false` → a rejection, NEVER a spend;
    *   • the spend is recorded EXACTLY ONCE, on an affirmative settlement only.
    */
-  async payExactRail(net, wallet, accept, url, init, quote, x402Version = 2) {
+  async payExactRail(net, wallet, accept, url, init, quote, x402Version = 2, reservation) {
     if (!net.payExact) {
       throw new UnsupportedSchemeError(
         `the ${net.family} family can't pay a standard 'exact' rail (supported on EVM, Solana, Algorand, Aptos + NEAR today).`
@@ -4919,7 +5031,7 @@ var PipRailClient = class {
         this.captureReceipt(response, url);
         this.safeEmit({ kind: "payment-settled", receipt, ...settle ? { settle } : {} });
         const ref = settle?.transaction || receipt?.transaction || `${net.family === "evm" ? "eip3009" : net.family}-nonce:${nonce}`;
-        this.recordSpend(quote, ref);
+        this.recordSpend(quote, ref, void 0, reservation);
         return response;
       }
       if (response.status >= 500) {
@@ -4950,7 +5062,7 @@ var PipRailClient = class {
    * `settle.amount` FAILS SAFE to the MAX (over-counts, never under-counts). The buyer SIGNS, the
    * merchant self-settles — the buyer never broadcasts.
    */
-  async payUptoRail(net, wallet, accept, url, init, quote) {
+  async payUptoRail(net, wallet, accept, url, init, quote, reservation) {
     if (!net.payUpto) {
       throw new UnsupportedSchemeError(
         `the ${net.family} family can't pay a standard 'upto' rail (EVM-Permit2 only today).`
@@ -5004,7 +5116,7 @@ var PipRailClient = class {
         this.safeEmit({ kind: "payment-settled", receipt, ...settle ? { settle } : {} });
         const ref = settle?.transaction || receipt?.transaction || `upto-nonce:${nonce}`;
         const settledAmount = settle?.amount ?? receipt?.amount;
-        this.recordSpend(quote, ref, settledAmount);
+        this.recordSpend(quote, ref, settledAmount, reservation);
         return response;
       }
       if (response.status >= 500) {
@@ -6018,7 +6130,7 @@ function renderLandingPage(sd) {
 }
 
 // src/facilitator.ts
-async function fetchFacilitatorFeePayer(url, network, timeoutMs = 8e3) {
+async function fetchFacilitatorFeePayer(url, network, timeoutMs = 15e3) {
   const base2 = url.replace(/\/+$/, "");
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), timeoutMs);
@@ -6058,7 +6170,7 @@ function parseFacilitatorSupported(body) {
   }
   return out;
 }
-async function facilitatorCoverage(url, timeoutMs = 8e3) {
+async function facilitatorCoverage(url, timeoutMs = 15e3) {
   const base2 = url.replace(/\/+$/, "");
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), timeoutMs);
@@ -6580,6 +6692,11 @@ function createPaymentGate(options) {
           net.assertValidPayTo(payTo);
           const { asset, decimals, symbol } = net.resolveToken(a.token);
           const amountBase = parseUnits(a.amount, decimals);
+          if (amountBase <= 0n) {
+            throw new InvalidConfigError(
+              `requirePayment: amount must be greater than zero, got "${a.amount}" on ${net.network}. A gate that charges nothing gates nothing; omit the gate instead.`
+            );
+          }
           const spec = { net, asset, decimals, symbol, amountBase, amountFormatted: a.amount, payTo };
           if (exactOption) {
             const outcome = await resolveExactRail(net, asset);
@@ -6698,6 +6815,11 @@ function createPaymentGate(options) {
       "requirePayment/createPaymentGate: `isUsed` and `markUsed` must be provided TOGETHER \u2014 a custom replay store needs both a read and a write. Supplying only " + (hasIsUsed ? "`isUsed`" : "`markUsed`") + " silently disables replay protection (double-spend). Provide both, or neither (the built-in in-memory store)."
     );
   }
+  if (typeof options.releaseUsed === "function" && !(hasIsUsed && hasMarkUsed)) {
+    throw new Error(
+      "requirePayment/createPaymentGate: `releaseUsed` needs `isUsed` + `markUsed` too \u2014 it releases a reservation a CUSTOM store made, so without one it would never fire. Provide all three, or none (the built-in store already releases on failure)."
+    );
+  }
   const hasCustomStore = hasIsUsed && hasMarkUsed;
   const localUsed = /* @__PURE__ */ new Map();
   const replayWindowMs = maxTimeoutSeconds * 1e3;
@@ -6707,23 +6829,35 @@ function createPaymentGate(options) {
       localUsed.delete(key);
     }
   }
+  const localKey = (ref) => ref.startsWith("pid:") ? ref : ref.toLowerCase();
   async function claimTx(ref) {
-    if (hasCustomStore) {
-      return options.isUsed ? Boolean(await options.isUsed(ref)) : false;
-    }
-    const key = ref.startsWith("pid:") ? ref : ref.toLowerCase();
+    const key = localKey(ref);
     const now = Date.now();
     pruneUsed(now);
     if (localUsed.has(key)) return true;
     localUsed.set(key, now + replayWindowMs);
+    if (hasCustomStore) {
+      try {
+        if (options.isUsed && await options.isUsed(ref)) return true;
+      } catch (err) {
+        localUsed.delete(key);
+        throw err;
+      }
+    }
     return false;
   }
   async function settleTx(ref, ok) {
-    if (hasCustomStore) {
-      if (ok && options.markUsed) await options.markUsed(ref);
+    if (!ok) {
+      localUsed.delete(localKey(ref));
+      if (hasCustomStore && options.releaseUsed) {
+        try {
+          await options.releaseUsed(ref);
+        } catch {
+        }
+      }
       return;
     }
-    if (!ok) localUsed.delete(ref.startsWith("pid:") ? ref : ref.toLowerCase());
+    if (hasCustomStore && options.markUsed) await options.markUsed(ref);
   }
   function buildAccept(s, nonce) {
     return {
@@ -7413,6 +7547,12 @@ function nonceIn(payload) {
   const fromAccept = typeof accepted?.extra?.nonce === "string" ? accepted.extra.nonce : void 0;
   return fromPayload ?? fromAccept;
 }
+function refIn(payload) {
+  if (typeof payload !== "object" || payload === null) return void 0;
+  const inner = payload.payload;
+  const ref = inner && typeof inner.txHash === "string" ? inner.txHash.trim() : void 0;
+  return ref ? ref.toLowerCase() : void 0;
+}
 function toToolError(err) {
   if (!(err instanceof PipRailError)) throw err;
   const out = {
@@ -7953,16 +8093,12 @@ function paymentTools(client) {
           const railSchemes = (t) => [
             ...new Set((t.rails ?? []).flatMap((r) => [...r.schemes ?? []]))
           ];
-          const shared = {
-            isUsed: (ref) => spentProofs.has(ref),
-            markUsed: (ref) => void spentProofs.add(ref)
-          };
-          let gate = createPaymentGate({ ...base3, ...shared, exact: true });
+          let gate = createPaymentGate({ ...base3, exact: true });
           let check = await gate.selfTest();
           const warnings = [];
           if (!check.ok || !railSchemes(check).includes("exact")) {
             const why = check.error ?? "it did not resolve on this RPC";
-            gate = createPaymentGate({ ...base3, ...shared });
+            gate = createPaymentGate({ ...base3 });
             check = await gate.selfTest();
             warnings.push(
               `This offer carries onchain-proof ONLY, so a standard x402 agent-buyer cannot pay it. A PipRail buyer (piprail_pay_request) and a human still can. The gasless exact rail was dropped because ${why} Two things cause this: the token or family has no exact scheme (a native coin never does, so price in USDC), or the token domain read failed on a busy public RPC, which is transient. Retrying on a dedicated rpcUrl is worth one attempt before you settle for this.`
@@ -8059,7 +8195,30 @@ function paymentTools(client) {
               next: "Do NOT deliver. Ask the buyer to pay THIS offer's challenge."
             };
           }
-          const result = asObject !== void 0 ? await offer.gate.verifyObject(asObject) : await offer.gate.verify(raw);
+          const proofRef = refIn(asObject ?? decodeBase64Json(raw));
+          let reservedHere;
+          if (proofRef) {
+            if (spentProofs.has(proofRef)) {
+              return {
+                ok: true,
+                paid: false,
+                offerId: offer.id,
+                reason: "this settlement was already collected \u2014 one payment settles exactly one offer.",
+                code: "tx_already_used",
+                next: "Do NOT deliver. Ask the buyer to pay THIS offer's challenge."
+              };
+            }
+            spentProofs.add(proofRef);
+            reservedHere = proofRef;
+          }
+          let result;
+          try {
+            result = asObject !== void 0 ? await offer.gate.verifyObject(asObject) : await offer.gate.verify(raw);
+          } catch (err) {
+            if (reservedHere) spentProofs.delete(reservedHere);
+            throw err;
+          }
+          if (result.kind !== "paid" && reservedHere) spentProofs.delete(reservedHere);
           if (result.kind === "paid") {
             const r = result.receipt;
             const entry = {

package/dist/{ledger-Crc1bZox.d.cts → ledger-DkHUORUe.d.cts}

@@ -1056,6 +1056,13 @@ declare class SpendLedger {
      *  {@link SpendStore} when one is configured (a failed append never throws). */
     record(r: SpendRecord, decimals: number, denom?: string): void;
     /** Running total (base units) already spent on this (network, asset). */
+    private readonly pending;
+    private pendingSeq;
+    /** Reserve budget for a payment about to be attempted. Returns the token to settle it with. */
+    reserve(network: string, asset: string, amountBase: bigint, decimals: number, denom?: string): string;
+    /** Drop a reservation: the payment settled (its real record now counts) or it failed. */
+    release(token: string | undefined): void;
+    private pendingFor;
     totalFor(network: string, asset: string): bigint;
     /**
      * Running grand total for a DENOMINATION, scaled to {@link DENOM_PRECISION} (so

package/dist/{ledger-Crc1bZox.d.ts → ledger-DkHUORUe.d.ts}

@@ -1056,6 +1056,13 @@ declare class SpendLedger {
      *  {@link SpendStore} when one is configured (a failed append never throws). */
     record(r: SpendRecord, decimals: number, denom?: string): void;
     /** Running total (base units) already spent on this (network, asset). */
+    private readonly pending;
+    private pendingSeq;
+    /** Reserve budget for a payment about to be attempted. Returns the token to settle it with. */
+    reserve(network: string, asset: string, amountBase: bigint, decimals: number, denom?: string): string;
+    /** Drop a reservation: the payment settled (its real record now counts) or it failed. */
+    release(token: string | undefined): void;
+    private pendingFor;
     totalFor(network: string, asset: string): bigint;
     /**
      * Running grand total for a DENOMINATION, scaled to {@link DENOM_PRECISION} (so

package/dist/node.d.cts

@@ -1,5 +1,5 @@
-import { v as SpendStore } from './ledger-Crc1bZox.cjs';
-export { _ as memorySpendStore } from './ledger-Crc1bZox.cjs';
+import { v as SpendStore } from './ledger-DkHUORUe.cjs';
+export { _ as memorySpendStore } from './ledger-DkHUORUe.cjs';
 
 /**
  * A durable {@link SpendStore} backed by a local JSONL file (one settled payment per

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { v as SpendStore } from './ledger-Crc1bZox.js';
-export { _ as memorySpendStore } from './ledger-Crc1bZox.js';
+import { v as SpendStore } from './ledger-DkHUORUe.js';
+export { _ as memorySpendStore } from './ledger-DkHUORUe.js';
 
 /**
  * A durable {@link SpendStore} backed by a local JSONL file (one settled payment per

package/dist/{solana-EBV6PUCU.cjs → solana-TIEJV742.cjs}

@@ -763,6 +763,7 @@ function toKeypair(wallet, network) {
 }
 
 // src/drivers/solana/index.ts
+var RENT_EXEMPT_MIN_LAMPORTS = 890880n;
 var solanaDriver = {
   family: "solana",
   resolve(opts) {
@@ -890,7 +891,12 @@ function makeSolanaNetwork(preset, rpcUrl) {
     async balanceOf(wallet, asset) {
       const owner = wallet._native.publicKey;
       const native = await connection.getBalance(owner).then((n) => BigInt(n)).catch(() => null);
-      if (asset === "native") return { token: native, native };
+      if (asset === "native") {
+        if (native === null) return { token: null, native };
+        const reserve = await connection.getMinimumBalanceForRentExemption(0).then((n) => BigInt(n)).catch(() => RENT_EXEMPT_MIN_LAMPORTS);
+        const spendable = native > reserve ? native - reserve : 0n;
+        return { token: spendable, native };
+      }
       let token;
       try {
         const mint = new (0, _web3js.PublicKey)(asset);

package/dist/{solana-O6Q6QILH.js → solana-WRXL54MR.js}

@@ -763,6 +763,7 @@ function toKeypair(wallet, network) {
 }
 
 // src/drivers/solana/index.ts
+var RENT_EXEMPT_MIN_LAMPORTS = 890880n;
 var solanaDriver = {
   family: "solana",
   resolve(opts) {
@@ -890,7 +891,12 @@ function makeSolanaNetwork(preset, rpcUrl) {
     async balanceOf(wallet, asset) {
       const owner = wallet._native.publicKey;
       const native = await connection.getBalance(owner).then((n) => BigInt(n)).catch(() => null);
-      if (asset === "native") return { token: native, native };
+      if (asset === "native") {
+        if (native === null) return { token: null, native };
+        const reserve = await connection.getMinimumBalanceForRentExemption(0).then((n) => BigInt(n)).catch(() => RENT_EXEMPT_MIN_LAMPORTS);
+        const spendable = native > reserve ? native - reserve : 0n;
+        return { token: spendable, native };
+      }
       let token;
       try {
         const mint = new PublicKey3(asset);

package/dist/{stellar-5C7FQLPS.cjs → stellar-5GMZJBTA.cjs}

@@ -419,6 +419,7 @@ function isStellarNotFound(e) {
   const x = e;
   return _optionalChain([x, 'optionalAccess', _14 => _14.response, 'optionalAccess', _15 => _15.status]) === 404 || _optionalChain([x, 'optionalAccess', _16 => _16.name]) === "NotFoundError";
 }
+var STELLAR_BASE_RESERVE = 5000000n;
 var stellarDriver = {
   family: "stellar",
   resolve(opts) {
@@ -550,9 +551,11 @@ function makeStellarNetwork(preset, rpcUrl) {
         return { token: null, native: null };
       }
       let lines;
+      let subentryCount;
       try {
         const account = await server.loadAccount(owner);
         lines = account.balances;
+        subentryCount = account.subentry_count;
       } catch (e) {
         return isStellarNotFound(e) ? { token: 0n, native: 0n } : { token: null, native: null };
       }
@@ -564,7 +567,12 @@ function makeStellarNetwork(preset, rpcUrl) {
         }
       };
       const native = toBase(_optionalChain([lines, 'access', _17 => _17.find, 'call', _18 => _18((b) => b.asset_type === "native"), 'optionalAccess', _19 => _19.balance]));
-      if (asset === "native") return { token: native, native };
+      if (asset === "native") {
+        if (native === null) return { token: null, native };
+        const subentries = BigInt(_nullishCoalesce(subentryCount, () => ( 0)));
+        const min = (2n + subentries) * STELLAR_BASE_RESERVE;
+        return { token: native > min ? native - min : 0n, native };
+      }
       const parts = parseStellarAssetId(asset);
       const line = parts ? lines.find(
         (b) => (b.asset_type === "credit_alphanum4" || b.asset_type === "credit_alphanum12") && b.asset_code === parts.code && b.asset_issuer === parts.issuer

package/dist/{stellar-YF5LOJEM.js → stellar-YQLOIFDD.js}

@@ -419,6 +419,7 @@ function isStellarNotFound(e) {
   const x = e;
   return x?.response?.status === 404 || x?.name === "NotFoundError";
 }
+var STELLAR_BASE_RESERVE = 5000000n;
 var stellarDriver = {
   family: "stellar",
   resolve(opts) {
@@ -550,9 +551,11 @@ function makeStellarNetwork(preset, rpcUrl) {
         return { token: null, native: null };
       }
       let lines;
+      let subentryCount;
       try {
         const account = await server.loadAccount(owner);
         lines = account.balances;
+        subentryCount = account.subentry_count;
       } catch (e) {
         return isStellarNotFound(e) ? { token: 0n, native: 0n } : { token: null, native: null };
       }
@@ -564,7 +567,12 @@ function makeStellarNetwork(preset, rpcUrl) {
         }
       };
       const native = toBase(lines.find((b) => b.asset_type === "native")?.balance);
-      if (asset === "native") return { token: native, native };
+      if (asset === "native") {
+        if (native === null) return { token: null, native };
+        const subentries = BigInt(subentryCount ?? 0);
+        const min = (2n + subentries) * STELLAR_BASE_RESERVE;
+        return { token: native > min ? native - min : 0n, native };
+      }
       const parts = parseStellarAssetId(asset);
       const line = parts ? lines.find(
         (b) => (b.asset_type === "credit_alphanum4" || b.asset_type === "credit_alphanum12") && b.asset_code === parts.code && b.asset_issuer === parts.issuer