@anywalletkit/wallet-near 0.0.0-stage → 0.1.3

package/dist/history.cjs

@@ -0,0 +1,538 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/history.ts
+var history_exports = {};
+__export(history_exports, {
+  HistoryUnavailableError: () => HistoryUnavailableError,
+  createNearHistory: () => createNearHistory,
+  decodeCursor: () => decodeCursor,
+  decodeFunctionCallArgs: () => decodeFunctionCallArgs,
+  encodeCursor: () => encodeCursor,
+  mapNearblocksGroup: () => mapNearblocksGroup,
+  mapNearblocksTxn: () => mapNearblocksTxn,
+  mapRpcTxStatus: () => mapRpcTxStatus,
+  nearExplorerTxUrl: () => nearExplorerTxUrl,
+  parseJsonPreservingBigInts: () => parseJsonPreservingBigInts
+});
+module.exports = __toCommonJS(history_exports);
+
+// src/rpc.ts
+var import_core = require("@anywalletkit/core");
+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"));
+}
+
+// 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 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_YOCTO = 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_YOCTO) 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_YOCTO) 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);
+    }
+  };
+}
+//# sourceMappingURL=history.cjs.map