@anywalletkit/wallet-near 0.0.0-stage → 0.1.3

package/dist/chunk-2GH6U3LB.js

@@ -0,0 +1,693 @@
+// src/rpc.ts
+import { NetworkError } from "@anywalletkit/core";
+
+// src/errors.ts
+var UnsafeTransactionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "UnsafeTransactionError";
+    this.code = code;
+  }
+};
+var SimulationError = class extends Error {
+  reason;
+  constructor(reason) {
+    super(`Transaction preflight failed: ${reason}`);
+    this.name = "SimulationError";
+    this.reason = reason;
+  }
+};
+var NearRpcError = class extends Error {
+  method;
+  errorName;
+  cause;
+  constructor(method, error) {
+    const causeName = error.cause?.name;
+    super(`${method}: ${error.name ?? "error"}${causeName ? ` / ${causeName}` : ""}${error.message ? ` \u2014 ${error.message}` : ""}`);
+    this.name = "NearRpcError";
+    this.method = method;
+    this.errorName = causeName ?? error.name;
+    this.cause = error;
+  }
+};
+
+// src/rpc.ts
+function toBase64(bytes) {
+  if (typeof btoa === "function") {
+    let s = "";
+    for (let i = 0; i < bytes.length; i += 32768) s += String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + 32768)));
+    return btoa(s);
+  }
+  return globalThis.Buffer.from(bytes).toString("base64");
+}
+function fromBase64(s) {
+  if (typeof atob === "function") {
+    const bin = atob(s);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  return new Uint8Array(globalThis.Buffer.from(s, "base64"));
+}
+function httpTransport(url, headers) {
+  let id = 0;
+  return async (method, params) => {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json", ...headers },
+      body: JSON.stringify({ jsonrpc: "2.0", id: String(++id), method, params })
+    });
+    if (!res.ok) throw new NetworkError(`${method}: HTTP ${res.status}`, { provider: url });
+    const json = await res.json();
+    if (json.error) throw new NearRpcError(method, json.error);
+    return json.result;
+  };
+}
+var isDefinitive = (e) => e instanceof NearRpcError && !/TIMEOUT|INTERNAL|UNAVAILABLE|NO_SYNCED/i.test(e.errorName ?? "");
+function createClient(config) {
+  if (config.provider === void 0) return void 0;
+  const list = (Array.isArray(config.provider) ? config.provider : [config.provider]).map(
+    (p) => typeof p === "string" ? httpTransport(p, config.headers) : p
+  );
+  if (list.length === 0) throw new Error("The 'provider' option cannot be set to an empty list.");
+  if (list.length === 1) return list[0];
+  const attempts = list.length + (config.retries ?? 3);
+  return async (method, params) => {
+    let lastError;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return await list[i % list.length](method, params);
+      } catch (e) {
+        if (isDefinitive(e)) throw e;
+        lastError = e;
+      }
+    }
+    throw new NetworkError(`All NEAR providers failed for ${method}`, { cause: lastError });
+  };
+}
+var UNKNOWN = /UNKNOWN_ACCOUNT|UNKNOWN_ACCESS_KEY|UNKNOWN_TRANSACTION|does not exist/i;
+var NearRpc = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  fetch;
+  /** `undefined` when the account does not exist. */
+  async viewAccount(accountId) {
+    try {
+      return await this.fetch("query", { request_type: "view_account", finality: "final", account_id: accountId });
+    } catch (e) {
+      if (e instanceof NearRpcError && UNKNOWN.test(e.errorName ?? e.message)) return void 0;
+      throw e;
+    }
+  }
+  /** `undefined` when the key is not on the account. */
+  async viewAccessKey(accountId, publicKey) {
+    try {
+      return await this.fetch("query", { request_type: "view_access_key", finality: "final", account_id: accountId, public_key: publicKey });
+    } catch (e) {
+      if (e instanceof NearRpcError && UNKNOWN.test(e.errorName ?? e.message)) return void 0;
+      throw e;
+    }
+  }
+  /** View call; the JSON-decoded return value (`null` for an empty result). */
+  async callFunction(contract, method, args = {}) {
+    const r = await this.fetch("query", {
+      request_type: "call_function",
+      finality: "final",
+      account_id: contract,
+      method_name: method,
+      args_base64: toBase64(new TextEncoder().encode(JSON.stringify(args)))
+    });
+    if (r.error) throw new NearRpcError("query", { name: "HANDLER_ERROR", message: r.error, cause: { name: "CONTRACT_EXECUTION_ERROR" } });
+    const text = new TextDecoder().decode(Uint8Array.from(r.result ?? []));
+    if (!text.length) return null;
+    return JSON.parse(text);
+  }
+  async latestBlockHash() {
+    const b = await this.fetch("block", { finality: "final" });
+    if (!b.header?.hash) throw new NetworkError("block: no header hash in the response");
+    return b.header.hash;
+  }
+  async gasPrice() {
+    const r = await this.fetch("gas_price", [null]);
+    if (!r.gas_price) throw new NetworkError("gas_price: no price in the response");
+    return BigInt(r.gas_price);
+  }
+  async sendTx(signedTxBase64, waitUntil = "EXECUTED_OPTIMISTIC") {
+    return await this.fetch("send_tx", { signed_tx_base64: signedTxBase64, wait_until: waitUntil });
+  }
+  /** `undefined` when the node does not know the transaction. */
+  async txStatus(hash, senderId) {
+    try {
+      return await this.fetch("tx", { tx_hash: hash, sender_account_id: senderId, wait_until: "NONE" });
+    } catch (e) {
+      if (e instanceof NearRpcError && UNKNOWN.test(e.errorName ?? e.message)) return void 0;
+      throw e;
+    }
+  }
+};
+function failureOf(status) {
+  if (!status || !("Failure" in status)) return void 0;
+  const f = status.Failure;
+  try {
+    const json = JSON.stringify(f);
+    const m = /"ExecutionError":"([^"]+)"/.exec(json) ?? /"error_message":"([^"]+)"/.exec(json) ?? /"kind":(\{[^}]*\})/.exec(json);
+    return m?.[1] ?? json.slice(0, 300);
+  } catch {
+    return String(f);
+  }
+}
+function outcomeFailed(o) {
+  const top = failureOf(o.status);
+  if (top) return top;
+  for (const r of o.receipts_outcome ?? []) {
+    const f = failureOf(r.outcome?.status);
+    if (f) return f;
+  }
+  return void 0;
+}
+
+// src/types.ts
+var CAIP2 = { mainnet: "near:mainnet", testnet: "near:testnet" };
+var YOCTO = 10n ** 24n;
+var TGAS = 10n ** 12n;
+var MAX_GAS = 300n * TGAS;
+var STORAGE_PRICE_PER_BYTE = 10n ** 19n;
+var ONE_YOCTO = 1n;
+var FT_TRANSFER_GAS = 30n * TGAS;
+var STORAGE_DEPOSIT_GAS = 10n * TGAS;
+var IMPLICIT_ACCOUNT_MIN_DEPOSIT = 2n * 10n ** 21n;
+
+// src/history.ts
+var HistoryUnavailableError = class extends Error {
+  chain;
+  reason;
+  attempts;
+  constructor(chain, reason, attempts = []) {
+    super(`History unavailable for ${chain}: ${reason}`);
+    this.name = "HistoryUnavailableError";
+    this.chain = chain;
+    this.reason = reason;
+    this.attempts = attempts;
+  }
+};
+var DEFAULT_LIMIT = 25;
+var MAX_LIMIT = 25;
+var DEFAULT_TIMEOUT_MS = 15e3;
+var ONE_YOCTO2 = 1n;
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function b64encode(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i += 3) {
+    const c = [s.charCodeAt(i), s.charCodeAt(i + 1), s.charCodeAt(i + 2)];
+    for (const x of c) if (x > 255) throw new Error("cursor must be ASCII");
+    const n = c[0] << 16 | (c[1] || 0) << 8 | (c[2] || 0);
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + (Number.isNaN(c[1]) ? "=" : B64[n >> 6 & 63]) + (Number.isNaN(c[2]) ? "=" : B64[n & 63]);
+  }
+  return out;
+}
+function b64decode(s) {
+  const clean = s.replace(/[^A-Za-z0-9+/]/g, "");
+  let out = "";
+  for (let i = 0; i < clean.length; i += 4) {
+    const c = [0, 1, 2, 3].map((k) => i + k < clean.length ? B64.indexOf(clean[i + k]) : -1);
+    if (c[0] < 0 || c[1] < 0) throw new Error("bad base64");
+    const n = c[0] << 18 | c[1] << 12 | (c[2] < 0 ? 0 : c[2]) << 6 | (c[3] < 0 ? 0 : c[3]);
+    out += String.fromCharCode(n >> 16 & 255);
+    if (c[2] >= 0) out += String.fromCharCode(n >> 8 & 255);
+    if (c[3] >= 0) out += String.fromCharCode(n & 255);
+  }
+  return out;
+}
+function encodeCursor(c) {
+  return b64encode(JSON.stringify(c));
+}
+function decodeCursor(s) {
+  let parsed;
+  try {
+    parsed = JSON.parse(b64decode(s));
+  } catch {
+    throw new Error("@anywalletkit/wallet-near: malformed history cursor");
+  }
+  const c = parsed;
+  const ok = (v) => v === null || typeof v === "string";
+  if (!c || c.v !== 1 || !ok(c.tx) || !ok(c.ft)) throw new Error("@anywalletkit/wallet-near: malformed history cursor");
+  return { v: 1, tx: c.tx, ft: c.ft };
+}
+var TokenBucket = class {
+  constructor(rate, burst = Math.max(2, Math.ceil(rate))) {
+    this.rate = rate;
+    this.burst = burst;
+    this.tokens = burst;
+  }
+  rate;
+  burst;
+  tokens;
+  last = Date.now();
+  chain = Promise.resolve();
+  acquire() {
+    const next = this.chain.then(() => this.take());
+    this.chain = next.catch(() => void 0);
+    return next;
+  }
+  refill() {
+    const now = Date.now();
+    this.tokens = Math.min(this.burst, this.tokens + (now - this.last) / 1e3 * this.rate);
+    this.last = now;
+  }
+  async take() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return;
+    }
+    await new Promise((r) => setTimeout(r, Math.ceil((1 - this.tokens) / this.rate * 1e3)));
+    this.refill();
+    this.tokens = Math.max(0, this.tokens - 1);
+  }
+};
+function timeoutSignal(ms) {
+  const ctor = globalThis.AbortSignal;
+  return typeof ctor?.timeout === "function" ? ctor.timeout(ms) : void 0;
+}
+function parseJsonPreservingBigInts(text) {
+  let out = "";
+  let i = 0;
+  let inString = false;
+  while (i < text.length) {
+    const ch = text[i];
+    if (inString) {
+      out += ch;
+      if (ch === "\\") {
+        out += text[i + 1] ?? "";
+        i += 2;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "-" || ch >= "0" && ch <= "9") {
+      let j = i;
+      if (text[j] === "-") j++;
+      while (j < text.length && text[j] >= "0" && text[j] <= "9") j++;
+      const next = text[j];
+      const isInteger = next !== "." && next !== "e" && next !== "E";
+      if (isInteger) {
+        const tok = text.slice(i, j);
+        out += tok.replace("-", "").length >= 16 ? `"${tok}"` : tok;
+        i = j;
+        continue;
+      }
+      while (j < text.length && /[0-9.eE+-]/.test(text[j])) j++;
+      out += text.slice(i, j);
+      i = j;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return JSON.parse(out);
+}
+function big(v, approx) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "string" && /^-?\d+$/.test(v)) return BigInt(v);
+  if (typeof v === "number" && Number.isFinite(v)) {
+    if (!Number.isSafeInteger(v)) approx.value = true;
+    return BigInt(Math.trunc(v));
+  }
+  return void 0;
+}
+var nsToSeconds = (ts) => {
+  if (typeof ts === "string" && /^\d+$/.test(ts)) return Number(BigInt(ts) / 1000000000n);
+  if (typeof ts === "number") return Math.floor(ts / 1e9);
+  return 0;
+};
+function ftTransfer(row, approx) {
+  const meta = row.ft ?? row.ft_meta;
+  if (!meta?.contract) return void 0;
+  const delta = big(row.delta_amount, approx);
+  if (delta === void 0 || delta === 0n) return void 0;
+  const other = row.involved_account_id ?? meta.contract;
+  const t = { token: meta.contract, from: delta < 0n ? row.affected_account_id : other, to: delta < 0n ? other : row.affected_account_id, amount: delta < 0n ? -delta : delta, standard: "nep141" };
+  if (typeof meta.symbol === "string") t.symbol = meta.symbol;
+  if (typeof meta.decimals === "number") t.decimals = meta.decimals;
+  return t;
+}
+function foldActions(actions, from, to, fold, approx) {
+  for (const a of actions ?? []) {
+    const deposit = big(a.deposit, approx) ?? 0n;
+    if (a.action === "TRANSFER") {
+      if (deposit > 0n) fold.transfers.push({ token: null, from, to, amount: deposit });
+      continue;
+    }
+    if (a.action === "DELEGATE_ACTION") continue;
+    const method = a.action === "FUNCTION_CALL" ? a.method ?? "function_call" : a.action.toLowerCase();
+    fold.programs.push(method);
+    if (a.action === "FUNCTION_CALL" && deposit > 0n && deposit !== ONE_YOCTO2) fold.transfers.push({ token: null, from, to, amount: deposit });
+    fold.call ??= { to, method, programs: fold.programs };
+  }
+}
+function mapNearblocksGroup(chain, address, receipts, ft) {
+  const approx = { value: false };
+  const rows = [...receipts].sort((a, b) => BigInt(a.id) < BigInt(b.id) ? -1 : BigInt(a.id) > BigInt(b.id) ? 1 : 0);
+  const real = rows.filter((r) => r.predecessor_account_id !== "system" && (r.receipt_kind ?? "ACTION") === "ACTION");
+  const fold = { transfers: [], programs: [] };
+  const ordered = [...real.filter((r) => r.receiver_account_id !== address), ...real.filter((r) => r.receiver_account_id === address)];
+  for (const r of ordered) foldActions(r.actions, r.predecessor_account_id, r.receiver_account_id, fold, approx);
+  for (const f of ft) {
+    const t = ftTransfer(f, approx);
+    if (t) fold.transfers.push(t);
+  }
+  const head = ordered[0] ?? rows[0] ?? ft[0];
+  const hash = head?.transaction_hash ?? "";
+  const from = ordered[0]?.predecessor_account_id ?? (ft.length ? ftTransfer(ft[0], approx)?.from ?? address : address);
+  const involves = (t) => t.from === address || t.to === address;
+  const primary = fold.transfers.find((t) => t.token !== null && involves(t)) ?? fold.transfers.find(involves) ?? fold.transfers[0];
+  const to = fold.call?.to ?? primary?.to ?? ordered[0]?.receiver_account_id ?? null;
+  let nativeValue = 0n;
+  for (const t of fold.transfers) if (t.token === null && t.from === from) nativeValue += t.amount;
+  const statuses = [...rows.map((r) => r.outcomes?.status), ...ft.map((r) => r.outcomes?.status)].filter((s) => typeof s === "boolean");
+  const status = statuses.length === 0 ? "confirmed" : statuses.every(Boolean) ? "confirmed" : "failed";
+  const feeSrc = rows.find((r) => r.outcomes_agg?.transaction_fee != null)?.outcomes_agg?.transaction_fee;
+  const fee = big(feeSrc, approx);
+  const heights = [...rows, ...ft].map((r) => r.block?.block_height).filter((h) => typeof h === "number");
+  const raw = { receipts: rows, ft };
+  if (approx.value) raw.approximate = true;
+  const out = {
+    chain,
+    hash,
+    time: nsToSeconds(head?.block_timestamp),
+    status,
+    address,
+    from,
+    to,
+    nativeValue,
+    transfers: fold.transfers,
+    raw
+  };
+  if (fee !== void 0) out.fee = fee;
+  if (fold.call) out.call = fold.call;
+  if (heights.length) out.block = BigInt(Math.min(...heights));
+  return out;
+}
+function mapNearblocksTxn(chain, address, txn) {
+  const approx = { value: false };
+  const fold = { transfers: [], programs: [] };
+  foldActions(txn.actions, txn.signer_account_id, txn.receiver_account_id, fold, approx);
+  for (const r of txn.receipts ?? []) {
+    for (const f of r.fts ?? []) {
+      const delta = big(f.delta_amount, approx);
+      if (delta === void 0 || delta >= 0n) continue;
+      const t = ftTransfer(f, approx);
+      if (t) fold.transfers.push(t);
+    }
+  }
+  const from = txn.signer_account_id;
+  const involves = (t) => t.from === address || t.to === address;
+  const primary = fold.transfers.find((t) => t.token !== null && involves(t)) ?? fold.transfers.find(involves) ?? fold.transfers[0];
+  let nativeValue = 0n;
+  for (const t of fold.transfers) if (t.token === null && t.from === from) nativeValue += t.amount;
+  const fee = big(txn.outcomes_agg?.transaction_fee, approx);
+  const raw = { receipts: [], ft: [], txn };
+  if (approx.value) raw.approximate = true;
+  const out = {
+    chain,
+    hash: txn.transaction_hash,
+    time: nsToSeconds(txn.block_timestamp),
+    status: txn.outcomes?.status === false ? "failed" : "confirmed",
+    address,
+    from,
+    to: fold.call?.to ?? primary?.to ?? txn.receiver_account_id,
+    nativeValue,
+    transfers: fold.transfers,
+    raw
+  };
+  if (fee !== void 0) out.fee = fee;
+  if (fold.call) out.call = fold.call;
+  if (typeof txn.block?.block_height === "number") out.block = BigInt(txn.block.block_height);
+  return out;
+}
+var utf8 = (bytes) => {
+  let s = "";
+  for (let i = 0; i < bytes.length; ) {
+    const b0 = bytes[i++];
+    let cp;
+    if (b0 < 128) cp = b0;
+    else if (b0 < 224) cp = (b0 & 31) << 6 | bytes[i++] & 63;
+    else if (b0 < 240) cp = (b0 & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
+    else cp = (b0 & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
+    s += String.fromCodePoint(cp);
+  }
+  return s;
+};
+function mapRpcTxStatus(chain, address, r, base) {
+  const tx = r.transaction;
+  const transfers = [];
+  const programs = [];
+  let call;
+  const walk = (actions, from2, to) => {
+    for (const a of actions ?? []) {
+      if (a.Transfer) {
+        const d = BigInt(a.Transfer.deposit);
+        if (d > 0n) transfers.push({ token: null, from: from2, to, amount: d });
+      } else if (a.FunctionCall) {
+        const d = BigInt(a.FunctionCall.deposit || "0");
+        programs.push(a.FunctionCall.method_name);
+        if (d > 0n && d !== ONE_YOCTO2) transfers.push({ token: null, from: from2, to, amount: d });
+        call ??= { to, method: a.FunctionCall.method_name, programs };
+      } else if (a.Delegate) {
+        walk(a.Delegate.delegate_action.actions, a.Delegate.delegate_action.sender_id, a.Delegate.delegate_action.receiver_id);
+      } else {
+        const name = Object.keys(a)[0];
+        if (name) {
+          const method = name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+          programs.push(method);
+          call ??= { to, method, programs };
+        }
+      }
+    }
+  };
+  if (tx) walk(tx.actions, tx.signer_id, tx.receiver_id);
+  let fee = 0n;
+  const burnt = r.transaction_outcome?.outcome?.tokens_burnt;
+  if (burnt) fee += BigInt(burnt);
+  let failed = false;
+  for (const ro of r.receipts_outcome ?? []) {
+    const o = ro.outcome;
+    if (!o) continue;
+    if (o.tokens_burnt) fee += BigInt(o.tokens_burnt);
+    if (o.status && "Failure" in o.status) failed = true;
+    const token = o.executor_id;
+    for (const log of o.logs ?? []) {
+      if (!token) continue;
+      const legacy = /^Transfer (\d+) from (\S+) to (\S+)$/.exec(log);
+      if (legacy) {
+        transfers.push({ token, from: legacy[2], to: legacy[3], amount: BigInt(legacy[1]), standard: "nep141" });
+        continue;
+      }
+      if (!log.startsWith("EVENT_JSON:")) continue;
+      let ev;
+      try {
+        ev = JSON.parse(log.slice("EVENT_JSON:".length));
+      } catch {
+        continue;
+      }
+      if (ev.standard !== "nep141") continue;
+      for (const d of ev.data ?? []) {
+        if (!d.amount || !/^\d+$/.test(d.amount)) continue;
+        if (ev.event === "ft_transfer" && d.old_owner_id && d.new_owner_id) transfers.push({ token, from: d.old_owner_id, to: d.new_owner_id, amount: BigInt(d.amount), standard: "nep141" });
+        else if (ev.event === "ft_mint" && d.owner_id) transfers.push({ token, from: token, to: d.owner_id, amount: BigInt(d.amount), standard: "nep141" });
+        else if (ev.event === "ft_burn" && d.owner_id) transfers.push({ token, from: d.owner_id, to: token, amount: BigInt(d.amount), standard: "nep141" });
+      }
+    }
+  }
+  if (r.status && "Failure" in r.status) failed = true;
+  for (const t of transfers) {
+    const known = base?.transfers.find((x) => x.token === t.token && (x.symbol !== void 0 || x.decimals !== void 0));
+    if (known?.symbol !== void 0) t.symbol = known.symbol;
+    if (known?.decimals !== void 0) t.decimals = known.decimals;
+  }
+  const from = tx?.signer_id ?? base?.from ?? address;
+  const involves = (t) => t.from === address || t.to === address;
+  const primary = transfers.find((t) => t.token !== null && involves(t)) ?? transfers.find(involves) ?? transfers[0];
+  let nativeValue = 0n;
+  for (const t of transfers) if (t.token === null && t.from === from) nativeValue += t.amount;
+  const raw = { ...base?.raw ?? { receipts: [], ft: [] }, rpc: r };
+  delete raw.approximate;
+  const out = {
+    chain,
+    hash: tx?.hash ?? base?.hash ?? "",
+    time: base?.time ?? 0,
+    status: failed ? "failed" : "confirmed",
+    address,
+    from,
+    to: call?.to ?? primary?.to ?? tx?.receiver_id ?? base?.to ?? null,
+    nativeValue,
+    transfers,
+    fee,
+    raw
+  };
+  if (call) out.call = call;
+  if (base?.block !== void 0) out.block = base.block;
+  return out;
+}
+function decodeFunctionCallArgs(args) {
+  try {
+    return JSON.parse(utf8(fromBase64(args)));
+  } catch {
+    return void 0;
+  }
+}
+function nearExplorerTxUrl(hash, network = "mainnet") {
+  return `https://${network === "testnet" ? "testnet." : ""}nearblocks.io/txns/${hash}`;
+}
+function createNearHistory(options = {}) {
+  const network = options.network ?? "mainnet";
+  const chain = CAIP2[network] ?? CAIP2.mainnet;
+  const base = (options.nearblocksUrl ?? (network === "testnet" ? "https://api-testnet.nearblocks.io" : "https://api.nearblocks.io")).replace(/\/+$/, "");
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (typeof fetchFn !== "function") throw new Error("@anywalletkit/wallet-near: no global fetch; pass `fetch` in the options");
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const bucket = new TokenBucket(options.rateLimit ?? (options.apiKey ? 5 : 0.1));
+  async function get(path) {
+    await bucket.acquire();
+    const url = `${base}${path}`;
+    let res;
+    try {
+      const signal = timeoutSignal(timeoutMs);
+      res = await fetchFn(url, { headers: { accept: "application/json", ...options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {} }, ...signal ? { signal } : {} });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new HistoryUnavailableError(chain, `${path}: ${msg}`, [`nearblocks: ${msg}`]);
+    }
+    const text = await res.text();
+    let body;
+    try {
+      body = parseJsonPreservingBigInts(text);
+    } catch {
+      body = void 0;
+    }
+    if (!res.ok) {
+      const msg = body?.message ?? `HTTP ${res.status}`;
+      throw new HistoryUnavailableError(chain, `${path}: ${msg}`, [`nearblocks: HTTP ${res.status} ${msg}`]);
+    }
+    return body;
+  }
+  async function rpcTxStatus(hash, signer) {
+    if (!options.rpcUrl) return void 0;
+    const signal = timeoutSignal(timeoutMs);
+    const res = await fetchFn(options.rpcUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: "1", method: "EXPERIMENTAL_tx_status", params: { tx_hash: hash, sender_account_id: signer, wait_until: "NONE" } }),
+      ...signal ? { signal } : {}
+    });
+    const json = JSON.parse(await res.text());
+    if (!res.ok || json.error || !json.result) return void 0;
+    return json.result;
+  }
+  return {
+    chain,
+    async listActivity(address, query = {}) {
+      const limit = Math.min(MAX_LIMIT, Math.max(1, Math.floor(query.limit ?? DEFAULT_LIMIT)));
+      const cursor = query.cursor ? decodeCursor(query.cursor) : { v: 1, tx: "", ft: "" };
+      const acct = encodeURIComponent(address);
+      const perPage = Math.min(MAX_LIMIT, limit * 2);
+      const txRows = cursor.tx === null ? [] : (await get(`/v1/account/${acct}/txns?per_page=${perPage}&order=desc${cursor.tx ? `&cursor=${encodeURIComponent(cursor.tx)}` : ""}`))?.txns ?? [];
+      const ftRows = cursor.ft === null ? [] : (await get(`/v1/account/${acct}/ft-txns?per_page=${limit}&order=desc${cursor.ft ? `&cursor=${encodeURIComponent(cursor.ft)}` : ""}`))?.txns ?? [];
+      const key = (r) => BigInt(typeof r.block_timestamp === "string" ? r.block_timestamp : Math.trunc(r.block_timestamp));
+      const all = [...txRows.map((r) => ({ k: key(r), h: r.transaction_hash })), ...ftRows.map((r) => ({ k: key(r), h: r.transaction_hash }))];
+      all.sort((a, b) => a.k > b.k ? -1 : a.k < b.k ? 1 : 0);
+      const chosen = /* @__PURE__ */ new Set();
+      let boundary;
+      for (const e of all) {
+        if (chosen.has(e.h)) continue;
+        if (chosen.size >= limit && boundary !== void 0 && e.k < boundary) break;
+        chosen.add(e.h);
+        if (chosen.size === limit) boundary = e.k;
+      }
+      const consume = (rows, asked, wasAt, pos) => {
+        if (wasAt === null) return { used: [], next: null };
+        let n = 0;
+        while (n < rows.length && chosen.has(rows[n].transaction_hash)) n++;
+        const used = rows.slice(0, n);
+        if (rows.length < asked && n === rows.length) return { used, next: null };
+        return { used, next: n > 0 ? pos(used[n - 1]) : wasAt };
+      };
+      const txC = consume(txRows, perPage, cursor.tx, (r) => r.id);
+      const ftC = consume(ftRows, limit, cursor.ft, (r) => r.event_index);
+      const nextTx = txC.next, nextFt = ftC.next;
+      const groups = /* @__PURE__ */ new Map();
+      for (const h of chosen) groups.set(h, { receipts: [], ft: [] });
+      for (const r of txC.used) groups.get(r.transaction_hash).receipts.push(r);
+      for (const r of ftC.used) groups.get(r.transaction_hash).ft.push(r);
+      let items = [...groups.entries()].map(([, g]) => mapNearblocksGroup(chain, address, g.receipts, g.ft)).filter((t) => t.hash);
+      items.sort((a, b) => b.time - a.time);
+      let more = nextTx !== null || nextFt !== null;
+      if (query.since !== void 0) {
+        const since = query.since;
+        if (items.some((t) => t.time < since)) more = false;
+        items = items.filter((t) => t.time >= since);
+      }
+      const page = { items };
+      if (more) page.cursor = encodeCursor({ v: 1, tx: nextTx, ft: nextFt });
+      return page;
+    },
+    async getTransaction(hash, address) {
+      const body = await get(`/v1/txns/${encodeURIComponent(hash)}`);
+      const txn = body?.txns?.[0];
+      if (!txn) return void 0;
+      const base2 = mapNearblocksTxn(chain, address, txn);
+      if (!options.rpcUrl) return base2;
+      try {
+        const r = await rpcTxStatus(hash, txn.signer_account_id);
+        return r ? mapRpcTxStatus(chain, address, r, base2) : base2;
+      } catch {
+        return base2;
+      }
+    },
+    explorerTxUrl(hash) {
+      return nearExplorerTxUrl(hash, network);
+    }
+  };
+}
+
+export {
+  CAIP2,
+  YOCTO,
+  TGAS,
+  MAX_GAS,
+  STORAGE_PRICE_PER_BYTE,
+  ONE_YOCTO,
+  FT_TRANSFER_GAS,
+  STORAGE_DEPOSIT_GAS,
+  IMPLICIT_ACCOUNT_MIN_DEPOSIT,
+  UnsafeTransactionError,
+  SimulationError,
+  NearRpcError,
+  toBase64,
+  fromBase64,
+  createClient,
+  NearRpc,
+  failureOf,
+  outcomeFailed,
+  HistoryUnavailableError,
+  encodeCursor,
+  decodeCursor,
+  parseJsonPreservingBigInts,
+  mapNearblocksGroup,
+  mapNearblocksTxn,
+  mapRpcTxStatus,
+  decodeFunctionCallArgs,
+  nearExplorerTxUrl,
+  createNearHistory
+};
+//# sourceMappingURL=chunk-2GH6U3LB.js.map