@anywalletkit/wallet-near 0.0.0-stage → 0.1.3

package/dist/index.cjs

@@ -0,0 +1,1749 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ACTION_TAG: () => ACTION_TAG,
+  BorshReader: () => BorshReader,
+  BorshWriter: () => BorshWriter,
+  CAIP2: () => CAIP2,
+  DANGEROUS_ACTIONS: () => DANGEROUS_ACTIONS,
+  FT_TRANSFER_GAS: () => FT_TRANSFER_GAS,
+  HistoryUnavailableError: () => HistoryUnavailableError,
+  IMPLICIT_ACCOUNT_MIN_DEPOSIT: () => IMPLICIT_ACCOUNT_MIN_DEPOSIT,
+  MAX_GAS: () => MAX_GAS,
+  NEAR_BASE_PATH: () => NEAR_BASE_PATH,
+  NEP413_PREFIX: () => NEP413_PREFIX,
+  NearRpc: () => NearRpc,
+  NearRpcError: () => NearRpcError,
+  ONE_YOCTO: () => ONE_YOCTO,
+  STORAGE_DEPOSIT_GAS: () => STORAGE_DEPOSIT_GAS,
+  STORAGE_PRICE_PER_BYTE: () => STORAGE_PRICE_PER_BYTE,
+  SimulationError: () => SimulationError,
+  TGAS: () => TGAS,
+  UnsafeTransactionError: () => UnsafeTransactionError,
+  WalletAccountNear: () => WalletAccountNear,
+  WalletAccountReadOnlyNear: () => WalletAccountReadOnlyNear,
+  WalletManagerNear: () => WalletManagerNear,
+  YOCTO: () => YOCTO,
+  actionKey: () => actionKey,
+  argsBytes: () => argsBytes,
+  base58ToBytes: () => base58ToBytes,
+  bytesToBase58: () => bytesToBase58,
+  createClient: () => createClient,
+  createNearHistory: () => createNearHistory,
+  decodeAnyTransaction: () => decodeAnyTransaction,
+  decodeFunctionCallArgs: () => decodeFunctionCallArgs,
+  decodeHistoryCursor: () => decodeCursor,
+  decodeSignedTransaction: () => decodeSignedTransaction,
+  decodeTransaction: () => decodeTransaction,
+  default: () => WalletManagerNear,
+  describeTransaction: () => describeTransaction,
+  ed25519Key: () => ed25519Key,
+  encodeHistoryCursor: () => encodeCursor,
+  encodeSignedTransaction: () => encodeSignedTransaction,
+  encodeTransaction: () => encodeTransaction,
+  failureOf: () => failureOf,
+  fromBase64: () => fromBase64,
+  implicitAccountId: () => implicitAccountId,
+  isDangerous: () => isDangerous,
+  isImplicitAccountId: () => isImplicitAccountId,
+  isValidAccountId: () => isValidAccountId,
+  mapNearblocksGroup: () => mapNearblocksGroup,
+  mapNearblocksTxn: () => mapNearblocksTxn,
+  mapRpcTxStatus: () => mapRpcTxStatus,
+  nearExplorerTxUrl: () => nearExplorerTxUrl,
+  nep413Bytes: () => nep413Bytes,
+  nep413Hash: () => nep413Hash,
+  outcomeFailed: () => outcomeFailed,
+  parseJsonPreservingBigInts: () => parseJsonPreservingBigInts,
+  parsePublicKey: () => parsePublicKey,
+  parseSignature: () => parseSignature,
+  publicKeyOfImplicit: () => publicKeyOfImplicit,
+  publicKeyToString: () => publicKeyToString,
+  readAction: () => readAction,
+  readPublicKey: () => readPublicKey,
+  readSignature: () => readSignature,
+  receiptOf: () => receiptOf,
+  toBase64: () => toBase64,
+  writeAction: () => writeAction,
+  writePublicKey: () => writePublicKey,
+  writeSignature: () => writeSignature
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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/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/address.ts
+var import_base = require("@scure/base");
+var import_utils = require("@noble/hashes/utils.js");
+var ACCOUNT_ID_RE = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+function isValidAccountId(id) {
+  return id.length >= 2 && id.length <= 64 && ACCOUNT_ID_RE.test(id);
+}
+function isImplicitAccountId(id) {
+  return id.length === 64 && /^[0-9a-f]{64}$/.test(id);
+}
+function implicitAccountId(publicKey) {
+  if (publicKey.length !== 32) throw new RangeError("ed25519 public key must be 32 bytes");
+  return (0, import_utils.bytesToHex)(publicKey);
+}
+function publicKeyToString(k) {
+  return `${k.keyType}:${import_base.base58.encode(k.data)}`;
+}
+function parsePublicKey(s) {
+  const [type, data] = s.includes(":") ? s.split(":", 2) : ["ed25519", s];
+  if (type !== "ed25519" && type !== "secp256k1") throw new RangeError(`unknown key type ${type}`);
+  const bytes = import_base.base58.decode(data);
+  const want = type === "ed25519" ? 32 : 64;
+  if (bytes.length !== want) throw new RangeError(`${type} public key must be ${want} bytes`);
+  return { keyType: type, data: bytes };
+}
+function ed25519Key(publicKey) {
+  if (publicKey.length !== 32) throw new RangeError("ed25519 public key must be 32 bytes");
+  return { keyType: "ed25519", data: publicKey };
+}
+function publicKeyOfImplicit(accountId) {
+  if (!isImplicitAccountId(accountId)) throw new RangeError(`${accountId} is not an implicit account id`);
+  return (0, import_utils.hexToBytes)(accountId);
+}
+function base58ToBytes(s, length) {
+  const b = import_base.base58.decode(s);
+  if (length !== void 0 && b.length !== length) throw new RangeError(`expected ${length} bytes, got ${b.length}`);
+  return b;
+}
+var bytesToBase58 = (b) => import_base.base58.encode(b);
+
+// src/borsh.ts
+var utf8 = new TextEncoder();
+var utf8d = new TextDecoder();
+var BorshWriter = class {
+  _buf = new Uint8Array(256);
+  _len = 0;
+  ensure(n) {
+    if (this._len + n <= this._buf.length) return;
+    const next = new Uint8Array(Math.max(this._buf.length * 2, this._len + n));
+    next.set(this._buf.subarray(0, this._len));
+    this._buf = next;
+  }
+  u8(v) {
+    this.ensure(1);
+    this._buf[this._len++] = v & 255;
+    return this;
+  }
+  u32(v) {
+    this.ensure(4);
+    for (let i = 0; i < 4; i++) this._buf[this._len++] = v >>> 8 * i & 255;
+    return this;
+  }
+  uint(v, bytes) {
+    if (v < 0n || v >= 1n << BigInt(8 * bytes)) throw new RangeError(`u${8 * bytes} out of range: ${v}`);
+    this.ensure(bytes);
+    for (let i = 0; i < bytes; i++) this._buf[this._len++] = Number(v >> BigInt(8 * i) & 0xffn);
+    return this;
+  }
+  u64(v) {
+    return this.uint(v, 8);
+  }
+  u128(v) {
+    return this.uint(v, 16);
+  }
+  bytes(b) {
+    this.ensure(b.length);
+    this._buf.set(b, this._len);
+    this._len += b.length;
+    return this;
+  }
+  /** Vec<u8> / String: u32 length + bytes. */
+  vecU8(b) {
+    return this.u32(b.length).bytes(b);
+  }
+  string(s) {
+    return this.vecU8(utf8.encode(s));
+  }
+  option(v, write) {
+    if (v === void 0) return this.u8(0);
+    this.u8(1);
+    write(v);
+    return this;
+  }
+  toBytes() {
+    return this._buf.slice(0, this._len);
+  }
+};
+var BorshReader = class {
+  constructor(_buf) {
+    this._buf = _buf;
+  }
+  _buf;
+  _pos = 0;
+  get remaining() {
+    return this._buf.length - this._pos;
+  }
+  need(n) {
+    if (this._pos + n > this._buf.length) throw new RangeError("borsh: unexpected end of input");
+  }
+  u8() {
+    this.need(1);
+    return this._buf[this._pos++];
+  }
+  u32() {
+    this.need(4);
+    let v = 0;
+    for (let i = 0; i < 4; i++) v |= this._buf[this._pos++] << 8 * i;
+    return v >>> 0;
+  }
+  uint(bytes) {
+    this.need(bytes);
+    let v = 0n;
+    for (let i = 0; i < bytes; i++) v |= BigInt(this._buf[this._pos++]) << BigInt(8 * i);
+    return v;
+  }
+  u64() {
+    return this.uint(8);
+  }
+  u128() {
+    return this.uint(16);
+  }
+  bytes(n) {
+    this.need(n);
+    const out = this._buf.slice(this._pos, this._pos + n);
+    this._pos += n;
+    return out;
+  }
+  vecU8() {
+    return this.bytes(this.u32());
+  }
+  string() {
+    return utf8d.decode(this.vecU8());
+  }
+  option(read) {
+    return this.u8() === 0 ? void 0 : read();
+  }
+  done() {
+    if (this.remaining !== 0) throw new RangeError(`borsh: ${this.remaining} trailing bytes`);
+  }
+};
+var KEY_TYPE = { ed25519: 0, secp256k1: 1 };
+var KEY_LEN = { ed25519: 32, secp256k1: 64 };
+var SIG_LEN = { ed25519: 64, secp256k1: 65 };
+function writePublicKey(w, k) {
+  if (k.data.length !== KEY_LEN[k.keyType]) throw new RangeError(`${k.keyType} public key must be ${KEY_LEN[k.keyType]} bytes`);
+  w.u8(KEY_TYPE[k.keyType]).bytes(k.data);
+}
+function readPublicKey(r) {
+  const t = r.u8();
+  const keyType = t === 0 ? "ed25519" : t === 1 ? "secp256k1" : void 0;
+  if (!keyType) throw new RangeError(`borsh: unknown key type ${t}`);
+  return { keyType, data: r.bytes(KEY_LEN[keyType]) };
+}
+function writeSignature(w, s) {
+  if (s.data.length !== SIG_LEN[s.keyType]) throw new RangeError(`${s.keyType} signature must be ${SIG_LEN[s.keyType]} bytes`);
+  w.u8(KEY_TYPE[s.keyType]).bytes(s.data);
+}
+function readSignature(r) {
+  const t = r.u8();
+  const keyType = t === 0 ? "ed25519" : t === 1 ? "secp256k1" : void 0;
+  if (!keyType) throw new RangeError(`borsh: unknown signature type ${t}`);
+  return { keyType, data: r.bytes(SIG_LEN[keyType]) };
+}
+var ACTION_TAG = {
+  createAccount: 0,
+  deployContract: 1,
+  functionCall: 2,
+  transfer: 3,
+  stake: 4,
+  addKey: 5,
+  deleteKey: 6,
+  deleteAccount: 7,
+  signedDelegate: 8,
+  deployGlobalContract: 9,
+  useGlobalContract: 10
+};
+function actionKey(a) {
+  const k = Object.keys(a)[0];
+  if (!k || !(k in ACTION_TAG)) throw new RangeError(`unknown action ${k}`);
+  return k;
+}
+function argsBytes(args) {
+  if (args instanceof Uint8Array) return args;
+  if (typeof args === "string") return utf8.encode(args);
+  return utf8.encode(JSON.stringify(args));
+}
+function writeAccessKey(w, k) {
+  w.u64(k.nonce);
+  if ("functionCall" in k.permission) {
+    const p = k.permission.functionCall;
+    w.u8(0);
+    w.option(p.allowance, (a) => w.u128(a));
+    w.string(p.receiverId);
+    w.u32(p.methodNames.length);
+    for (const m of p.methodNames) w.string(m);
+  } else {
+    w.u8(1);
+  }
+}
+function readAccessKey(r) {
+  const nonce = r.u64();
+  const t = r.u8();
+  if (t === 0) {
+    const allowance = r.option(() => r.u128());
+    const receiverId = r.string();
+    const n = r.u32();
+    const methodNames = [];
+    for (let i = 0; i < n; i++) methodNames.push(r.string());
+    return { nonce, permission: { functionCall: { ...allowance !== void 0 ? { allowance } : {}, receiverId, methodNames } } };
+  }
+  if (t === 1) return { nonce, permission: { fullAccess: {} } };
+  throw new RangeError(`borsh: unknown access-key permission ${t}`);
+}
+function writeDelegateAction(w, d) {
+  w.string(d.senderId).string(d.receiverId);
+  w.u32(d.actions.length);
+  for (const a of d.actions) writeAction(w, a);
+  w.u64(d.nonce).u64(d.maxBlockHeight);
+  writePublicKey(w, d.publicKey);
+}
+function readDelegateAction(r) {
+  const senderId = r.string();
+  const receiverId = r.string();
+  const n = r.u32();
+  const actions = [];
+  for (let i = 0; i < n; i++) actions.push(readAction(r));
+  const nonce = r.u64();
+  const maxBlockHeight = r.u64();
+  return { senderId, receiverId, actions, nonce, maxBlockHeight, publicKey: readPublicKey(r) };
+}
+function writeAction(w, a) {
+  const key = actionKey(a);
+  w.u8(ACTION_TAG[key]);
+  switch (key) {
+    case "createAccount":
+      return;
+    case "deployContract":
+      w.vecU8(a.deployContract.code);
+      return;
+    case "functionCall": {
+      const f = a.functionCall;
+      w.string(f.methodName).vecU8(argsBytes(f.args)).u64(f.gas ?? 30n * 10n ** 12n).u128(f.deposit ?? 0n);
+      return;
+    }
+    case "transfer":
+      w.u128(a.transfer.deposit);
+      return;
+    case "stake": {
+      const s = a.stake;
+      w.u128(s.stake);
+      writePublicKey(w, s.publicKey);
+      return;
+    }
+    case "addKey": {
+      const k = a.addKey;
+      writePublicKey(w, k.publicKey);
+      writeAccessKey(w, k.accessKey);
+      return;
+    }
+    case "deleteKey":
+      writePublicKey(w, a.deleteKey.publicKey);
+      return;
+    case "deleteAccount":
+      w.string(a.deleteAccount.beneficiaryId);
+      return;
+    case "signedDelegate": {
+      const d = a.signedDelegate;
+      writeDelegateAction(w, d.delegateAction);
+      writeSignature(w, d.signature);
+      return;
+    }
+    case "deployGlobalContract": {
+      const g = a.deployGlobalContract;
+      w.vecU8(g.code).u8(g.deployMode === "codeHash" ? 0 : 1);
+      return;
+    }
+    case "useGlobalContract": {
+      const u = a.useGlobalContract;
+      if ("codeHash" in u) {
+        w.u8(0).bytes(u.codeHash);
+      } else {
+        w.u8(1).string(u.accountId);
+      }
+      return;
+    }
+  }
+}
+function readAction(r) {
+  const tag = r.u8();
+  switch (tag) {
+    case 0:
+      return { createAccount: {} };
+    case 1:
+      return { deployContract: { code: r.vecU8() } };
+    case 2: {
+      const methodName = r.string();
+      const args = r.vecU8();
+      const gas = r.u64();
+      const deposit = r.u128();
+      return { functionCall: { methodName, args, gas, deposit } };
+    }
+    case 3:
+      return { transfer: { deposit: r.u128() } };
+    case 4: {
+      const stake = r.u128();
+      return { stake: { stake, publicKey: readPublicKey(r) } };
+    }
+    case 5: {
+      const publicKey = readPublicKey(r);
+      return { addKey: { publicKey, accessKey: readAccessKey(r) } };
+    }
+    case 6:
+      return { deleteKey: { publicKey: readPublicKey(r) } };
+    case 7:
+      return { deleteAccount: { beneficiaryId: r.string() } };
+    case 8: {
+      const delegateAction = readDelegateAction(r);
+      return { signedDelegate: { delegateAction, signature: readSignature(r) } };
+    }
+    case 9: {
+      const code = r.vecU8();
+      const m = r.u8();
+      return { deployGlobalContract: { code, deployMode: m === 0 ? "codeHash" : "accountId" } };
+    }
+    case 10: {
+      const m = r.u8();
+      return { useGlobalContract: m === 0 ? { codeHash: r.bytes(32) } : { accountId: r.string() } };
+    }
+    default:
+      throw new RangeError(`borsh: unknown action tag ${tag}`);
+  }
+}
+function encodeTransaction(tx) {
+  if (tx.blockHash.length !== 32) throw new RangeError("blockHash must be 32 bytes");
+  const w = new BorshWriter();
+  w.string(tx.signerId);
+  writePublicKey(w, tx.publicKey);
+  w.u64(tx.nonce).string(tx.receiverId).bytes(tx.blockHash);
+  w.u32(tx.actions.length);
+  for (const a of tx.actions) writeAction(w, a);
+  return w.toBytes();
+}
+function readTransaction(r) {
+  const signerId = r.string();
+  const publicKey = readPublicKey(r);
+  const nonce = r.u64();
+  const receiverId = r.string();
+  const blockHash = r.bytes(32);
+  const n = r.u32();
+  const actions = [];
+  for (let i = 0; i < n; i++) actions.push(readAction(r));
+  return { signerId, publicKey, nonce, receiverId, blockHash, actions };
+}
+function decodeTransaction(bytes) {
+  const r = new BorshReader(bytes);
+  const tx = readTransaction(r);
+  r.done();
+  return tx;
+}
+function encodeSignedTransaction(s) {
+  const w = new BorshWriter();
+  w.bytes(encodeTransaction(s.transaction));
+  writeSignature(w, s.signature);
+  return w.toBytes();
+}
+function decodeSignedTransaction(bytes) {
+  const r = new BorshReader(bytes);
+  const transaction = readTransaction(r);
+  const signature = readSignature(r);
+  r.done();
+  return { transaction, signature };
+}
+function decodeAnyTransaction(bytes) {
+  const r = new BorshReader(bytes);
+  const transaction = readTransaction(r);
+  if (r.remaining === 0) return { transaction };
+  const signature = readSignature(r);
+  r.done();
+  return { transaction, signature };
+}
+
+// src/rpc.ts
+var import_core = require("@anywalletkit/core");
+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 import_core.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 import_core.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 import_core.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 import_core.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/describe.ts
+var DANGEROUS_ACTIONS = /* @__PURE__ */ new Set(["createAccount", "deployContract", "stake", "addKey", "deleteKey", "deleteAccount", "signedDelegate", "deployGlobalContract", "useGlobalContract"]);
+var KIND_OF_DANGEROUS = {
+  createAccount: "create-account",
+  deployContract: "deploy-contract",
+  stake: "stake",
+  addKey: "add-key",
+  deleteKey: "delete-key",
+  deleteAccount: "delete-account",
+  signedDelegate: "delegate",
+  deployGlobalContract: "global-contract",
+  useGlobalContract: "global-contract"
+};
+var FT_METHODS = /* @__PURE__ */ new Set(["ft_transfer", "ft_transfer_call", "storage_deposit", "storage_withdraw", "storage_unregister"]);
+function parseArgs(a) {
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(argsBytes(a.args)));
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function describeTransaction(tx, ctx = {}) {
+  const warnings = [];
+  const actions = tx.actions ?? [];
+  const from = tx.signerId ?? ctx.signerId;
+  let deposit = 0n;
+  let gas = 0n;
+  const methods = [];
+  let kind = "batch";
+  let to = tx.receiverId;
+  let amount;
+  let token;
+  let memo;
+  let contract;
+  let dangerous;
+  if (!isValidAccountId(tx.receiverId)) warnings.push({ code: "invalid-account", message: `"${tx.receiverId}" is not a valid NEAR account id.` });
+  for (const a of actions) {
+    let key;
+    try {
+      key = actionKey(a);
+    } catch {
+      warnings.push({ code: "dangerous-action", message: "Unknown action." });
+      continue;
+    }
+    if (DANGEROUS_ACTIONS.has(key)) {
+      dangerous ??= KIND_OF_DANGEROUS[key];
+      warnings.push({ code: "dangerous-action", message: `${key} changes the account, its keys or its code.` });
+      if (key === "addKey" && "fullAccess" in a.addKey.accessKey.permission) {
+        warnings.push({ code: "full-access-key", message: "Adds a FULL ACCESS key: whoever holds it owns the account." });
+      }
+      continue;
+    }
+    if (key === "transfer") {
+      const d = a.transfer.deposit;
+      deposit += d;
+      amount = (amount ?? 0n) + d;
+      continue;
+    }
+    if (key === "functionCall") {
+      const f = a.functionCall;
+      const g = f.gas ?? 30n * TGAS;
+      gas += g;
+      deposit += f.deposit ?? 0n;
+      methods.push(f.methodName);
+      contract = tx.receiverId;
+      if (f.methodName === "ft_transfer" || f.methodName === "ft_transfer_call") {
+        const args = parseArgs(f);
+        token = tx.receiverId;
+        to = typeof args?.receiver_id === "string" ? args.receiver_id : void 0;
+        if (typeof args?.amount === "string" && /^\d+$/.test(args.amount)) amount = BigInt(args.amount);
+        if (typeof args?.memo === "string") memo = args.memo;
+        if (to !== void 0 && !isValidAccountId(to)) warnings.push({ code: "invalid-account", message: `"${to}" is not a valid NEAR account id.` });
+      }
+    }
+  }
+  const callMethods = methods.filter((m) => m !== "storage_deposit");
+  if (dangerous) kind = dangerous;
+  else if (actions.length === 1 && methods.length === 0 && amount !== void 0) kind = "near-transfer";
+  else if (methods.length > 0 && callMethods.every((m) => m === "ft_transfer" || m === "ft_transfer_call") && callMethods.length === 1 && actions.length === methods.length) kind = "ft-transfer";
+  else if (methods.length === 1 && methods[0] === "storage_deposit" && actions.length === 1) kind = "ft-storage-deposit";
+  else if (methods.length === 1 && actions.length === 1) kind = "function-call";
+  else kind = "batch";
+  if (kind === "function-call" && !FT_METHODS.has(methods[0])) warnings.push({ code: "unknown-method", message: `Calls ${tx.receiverId}.${methods[0]} \u2014 not a token method we recognise.` });
+  if ((kind === "near-transfer" || kind === "ft-transfer") && amount === 0n) warnings.push({ code: "zero-amount", message: "Transfers nothing." });
+  if (gas > MAX_GAS) warnings.push({ code: "high-gas", message: `Prepaid gas ${gas} exceeds the 300 Tgas transaction limit.` });
+  if (from !== void 0 && to !== void 0 && from === to && (kind === "near-transfer" || kind === "ft-transfer")) warnings.push({ code: "self-transfer", message: "Sends to the signing account itself." });
+  if (kind === "near-transfer" && ctx.recipientExists === false) {
+    if (isImplicitAccountId(tx.receiverId)) {
+      warnings.push({ code: "implicit-new-account", message: `Creates the implicit account ${tx.receiverId}${(amount ?? 0n) < IMPLICIT_ACCOUNT_MIN_DEPOSIT ? " \u2014 below the 0.002 NEAR it needs to exist" : ""}.` });
+    } else {
+      warnings.push({ code: "invalid-account", message: `Account ${tx.receiverId} does not exist; a transfer to it would fail.` });
+    }
+  }
+  return {
+    kind,
+    warnings,
+    deposit,
+    gas,
+    actionCount: actions.length,
+    ...from !== void 0 ? { from } : {},
+    ...to !== void 0 ? { to } : {},
+    ...amount !== void 0 ? { amount } : {},
+    ...token !== void 0 ? { token } : {},
+    ...memo !== void 0 ? { memo } : {},
+    ...contract !== void 0 ? { contract } : {},
+    ...methods.length ? { methods } : {}
+  };
+}
+var isDangerous = (a) => {
+  try {
+    return DANGEROUS_ACTIONS.has(actionKey(a));
+  } catch {
+    return true;
+  }
+};
+
+// src/nep413.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+var NEP413_PREFIX = 2 ** 31 + 413;
+function nep413Bytes(p) {
+  if (p.nonce.length !== 32) throw new RangeError("NEP-413 nonce must be 32 bytes");
+  const w = new BorshWriter();
+  w.u32(NEP413_PREFIX);
+  w.string(p.message).bytes(p.nonce).string(p.recipient);
+  w.option(p.callbackUrl, (u) => w.string(u));
+  return w.toBytes();
+}
+function nep413Hash(p) {
+  return (0, import_sha2.sha256)(nep413Bytes(p));
+}
+
+// src/read-only-account.ts
+var import_core2 = require("@anywalletkit/core");
+var import_ed25519 = require("@noble/curves/ed25519.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var ACTION_RECEIPT_GAS = 2n * 108059500000n;
+var TRANSFER_GAS = 2n * 115123062500n;
+var CREATE_ACCOUNT_GAS = 16n * 10n ** 12n;
+var FUNCTION_CALL_BASE_GAS = 2n * 2319861500000n;
+var FUNCTION_CALL_PER_BYTE_GAS = 2n * 2473250n;
+var IMPLICIT_ACCOUNT_CREATION_COST = 8n * 10n ** 21n;
+var GAS_PRICE_MARGIN_NUM = 11n;
+var GAS_PRICE_MARGIN_DEN = 10n;
+var MAX_STORAGE_DEPOSIT = 12500000000000000000000n;
+var WalletAccountReadOnlyNear = class _WalletAccountReadOnlyNear {
+  /** Account id: the implicit hex id of the key, or a named account bound to it. */
+  address;
+  chain;
+  publicKey;
+  _config;
+  _client;
+  _rpc;
+  /**
+   * @param address account id; an implicit (64-hex) id also fixes the public key.
+   * @param publicKey required for a named account (the key the account signs with).
+   */
+  constructor(address, config = {}, publicKey) {
+    if (!isValidAccountId(address)) throw new RangeError(`"${address}" is not a valid NEAR account id`);
+    this.address = address;
+    const key = publicKey instanceof Uint8Array ? ed25519Key(publicKey) : publicKey;
+    if (key) this.publicKey = key;
+    else if (isImplicitAccountId(address)) this.publicKey = ed25519Key(publicKeyOfImplicit(address));
+    else throw new RangeError("A named NEAR account needs its public key.");
+    this._config = config;
+    this._client = createClient(config);
+    this._rpc = this._client ? new NearRpc(this._client) : void 0;
+    const net = config.network ?? "mainnet";
+    this.chain = CAIP2[net] ?? (net.startsWith("near:") ? net : `near:${net}`);
+  }
+  /** "ed25519:<base58>" */
+  get publicKeyString() {
+    return publicKeyToString(this.publicKey);
+  }
+  requireRpc(what) {
+    if (!this._rpc) throw new import_core2.NetworkError(`The wallet must be connected to a provider to ${what}.`);
+    return this._rpc;
+  }
+  /** The account id. */
+  async getAddress() {
+    return this.address;
+  }
+  /** The account as the node sees it; `undefined` when it does not exist yet. */
+  async getAccountView(accountId = this.address) {
+    const v = await this.requireRpc("retrieve balances").viewAccount(accountId);
+    if (!v) return void 0;
+    const amount = BigInt(v.amount);
+    const locked = BigInt(v.locked);
+    const storageUsage = BigInt(v.storage_usage);
+    const available = amount - locked - storageUsage * STORAGE_PRICE_PER_BYTE;
+    return { amount, locked, storageUsage, available: available > 0n ? available : 0n };
+  }
+  /** Total NEAR balance in yoctoNEAR (0 for an account that does not exist yet). */
+  async getBalance() {
+    return (await this.getAccountView())?.amount ?? 0n;
+  }
+  /** What can actually be spent: total − locked (staked) − storage reservation. */
+  async getAvailableBalance() {
+    return (await this.getAccountView())?.available ?? 0n;
+  }
+  /** True when the account exists on chain. */
+  async accountExists(accountId) {
+    return await this.requireRpc("check an account").viewAccount(accountId) !== void 0;
+  }
+  /** NEP-141 `ft_balance_of`. */
+  async getTokenBalance(token) {
+    const r = await this.requireRpc("retrieve token balances").callFunction(token, "ft_balance_of", { account_id: this.address });
+    return BigInt(r ?? "0");
+  }
+  /** Several NEP-141 balances in parallel, keyed by the token contracts as given. */
+  async getTokenBalances(tokens) {
+    const out = {};
+    await Promise.all(tokens.map(async (t) => {
+      out[t] = await this.getTokenBalance(t);
+    }));
+    return out;
+  }
+  /** NEP-145 storage registration of `accountId` on a token contract (`null` = not registered). */
+  async getStorageBalance(token, accountId = this.address) {
+    const r = await this.requireRpc("read token storage").callFunction(token, "storage_balance_of", { account_id: accountId });
+    return r ? { total: BigInt(r.total), available: BigInt(r.available) } : null;
+  }
+  /** Minimum deposit a token contract wants for a registration (`storage_balance_bounds.min`). */
+  async getStorageDepositMin(token) {
+    const r = await this.requireRpc("read token storage").callFunction(token, "storage_balance_bounds", {});
+    const min = r?.min ?? "1250000000000000000000";
+    if (typeof min !== "string" || !/^\d{1,40}$/.test(min)) throw new UnsafeTransactionError("storage-deposit", `${token} returned a malformed storage_balance_bounds.min.`);
+    return BigInt(min);
+  }
+  // ── Building ────────────────────────────────────────────────────────────────
+  /**
+   * The actions for `transfer`: native → one Transfer; NEP-141 → `ft_transfer` (1 yocto, 30 Tgas),
+   * preceded by `storage_deposit` when the recipient is not registered on the token.
+   */
+  async transferActions(o) {
+    const amount = BigInt(o.amount);
+    if (!isValidAccountId(o.recipient)) throw new UnsafeTransactionError("invalid-account", `"${o.recipient}" is not a valid NEAR account id.`);
+    if (!o.token) return { receiverId: o.recipient, actions: [{ transfer: { deposit: amount } }] };
+    if (!isValidAccountId(o.token)) throw new UnsafeTransactionError("invalid-account", `"${o.token}" is not a valid token contract id.`);
+    const actions = [];
+    const registered = await this.getStorageBalance(o.token, o.recipient);
+    if (registered === null) {
+      const min = await this.getStorageDepositMin(o.token);
+      const cap = BigInt(this._config.maxStorageDeposit ?? MAX_STORAGE_DEPOSIT);
+      if (min > cap) throw new UnsafeTransactionError("storage-deposit", `${o.token} asks ${min} yoctoNEAR to register ${o.recipient}; the cap is ${cap}.`);
+      actions.push({ functionCall: { methodName: "storage_deposit", args: { account_id: o.recipient, registration_only: true }, gas: STORAGE_DEPOSIT_GAS, deposit: min } });
+    }
+    actions.push({
+      functionCall: {
+        methodName: "ft_transfer",
+        args: { receiver_id: o.recipient, amount: amount.toString(), ...o.memo !== void 0 ? { memo: o.memo } : {} },
+        gas: FT_TRANSFER_GAS,
+        deposit: ONE_YOCTO
+      }
+    });
+    return { receiverId: o.token, actions };
+  }
+  /** Fill `signerId` / `publicKey` / `nonce` / `blockHash` (the last two from the node when missing). */
+  async buildTransaction(tx) {
+    if (typeof tx === "string") return decodeAnyTransaction(fromBase64(tx)).transaction;
+    const signerId = tx.signerId ?? this.address;
+    const publicKey = tx.publicKey ?? this.publicKey;
+    let nonce = tx.nonce;
+    let blockHash = typeof tx.blockHash === "string" ? base58ToBytes(tx.blockHash, 32) : tx.blockHash;
+    if (nonce === void 0 || blockHash === void 0) {
+      const rpc = this.requireRpc("build transactions");
+      if (nonce === void 0) {
+        const key = await rpc.viewAccessKey(signerId, publicKeyToString(publicKey));
+        if (!key) throw new UnsafeTransactionError("no-access-key", `${publicKeyToString(publicKey)} is not an access key of ${signerId} (does the account exist and hold NEAR?).`);
+        nonce = BigInt(key.nonce) + 1n;
+      }
+      blockHash ??= base58ToBytes(await rpc.latestBlockHash(), 32);
+    }
+    return { signerId, publicKey, nonce, receiverId: tx.receiverId, blockHash, actions: tx.actions };
+  }
+  // ── Fees ────────────────────────────────────────────────────────────────────
+  /** Gas upper bound for the actions (prepaid function-call gas in full). */
+  static gasOf(actions, createsAccount) {
+    let gas = ACTION_RECEIPT_GAS;
+    for (const a of actions) {
+      if ("transfer" in a) gas += TRANSFER_GAS + (createsAccount ? CREATE_ACCOUNT_GAS : 0n);
+      else if ("functionCall" in a) {
+        const f = a.functionCall;
+        const argLen = f.args instanceof Uint8Array ? f.args.length : typeof f.args === "string" ? f.args.length : JSON.stringify(f.args).length;
+        gas += FUNCTION_CALL_BASE_GAS + FUNCTION_CALL_PER_BYTE_GAS * BigInt(argLen + f.methodName.length) + (f.gas ?? 30n * TGAS);
+      } else gas += 5n * TGAS;
+    }
+    return gas;
+  }
+  static depositOf(actions) {
+    let d = 0n;
+    for (const a of actions) {
+      if ("transfer" in a) d += a.transfer.deposit;
+      else if ("functionCall" in a) d += a.functionCall.deposit ?? 0n;
+      else if ("stake" in a) d += a.stake.stake;
+    }
+    return d;
+  }
+  async estimate(tx, recipientExists) {
+    const rpc = this.requireRpc("estimate fees");
+    const isTransfer = tx.actions.some((a) => "transfer" in a);
+    const createsAccount = isTransfer && isImplicitAccountId(tx.receiverId) && !(recipientExists ?? await this.accountExists(tx.receiverId));
+    const gas = _WalletAccountReadOnlyNear.gasOf(tx.actions, createsAccount);
+    const gasPrice = await rpc.gasPrice() * GAS_PRICE_MARGIN_NUM / GAS_PRICE_MARGIN_DEN;
+    const fee = gas * gasPrice + (createsAccount ? IMPLICIT_ACCOUNT_CREATION_COST : 0n);
+    return { gas, gasPrice, fee, deposit: _WalletAccountReadOnlyNear.depositOf(tx.actions), createsAccount };
+  }
+  /** Gas and cost of a transaction. */
+  async estimateFee(tx) {
+    return this.estimate(typeof tx === "string" ? await this.buildTransaction(tx) : tx);
+  }
+  /** Fee of a transaction in yoctoNEAR. */
+  async quoteSendTransaction(tx) {
+    const estimate = await this.estimateFee(tx);
+    return { fee: estimate.fee, estimate };
+  }
+  /** Fee of a transfer in yoctoNEAR, for the same actions `transfer` would send. */
+  async quoteTransfer(o) {
+    return this.quoteSendTransaction(await this.transferActions(o));
+  }
+  // ── Preflight ───────────────────────────────────────────────────────────────
+  /**
+   * Predict failure without signing: the signer account and its access key exist,
+   * the spendable balance covers deposits + fee, a named recipient exists (an
+   * implicit one may be created, for ≥ 0.002 NEAR), the token balance covers an
+   * `ft_transfer`. Transport failures throw; predicted failures don't.
+   */
+  async simulateTransaction(tx, estimate) {
+    const rpc = this.requireRpc("simulate transactions");
+    const signerId = tx.signerId ?? this.address;
+    const d = describeTransaction(tx, { signerId });
+    const acct = await this.getAccountView(signerId);
+    if (!acct) return { ok: false, reason: `Account ${signerId} does not exist (fund it with NEAR first).` };
+    const key = await rpc.viewAccessKey(signerId, publicKeyToString(tx.publicKey ?? this.publicKey));
+    if (!key) return { ok: false, reason: `${publicKeyToString(tx.publicKey ?? this.publicKey)} is not an access key of ${signerId}.` };
+    if (key.permission !== "FullAccess") {
+      const p = key.permission.FunctionCall;
+      if (p.receiver_id !== tx.receiverId || d.deposit > 0n) return { ok: false, reason: `The access key may only call ${p.receiver_id} without a deposit.` };
+      if (p.method_names.length && d.methods?.some((m) => !p.method_names.includes(m))) return { ok: false, reason: "The access key does not allow this method." };
+    }
+    let recipientExists;
+    if (d.kind === "near-transfer") {
+      recipientExists = await this.accountExists(tx.receiverId);
+      if (!recipientExists) {
+        if (!isImplicitAccountId(tx.receiverId)) return { ok: false, reason: `Account ${tx.receiverId} does not exist.` };
+        if ((d.amount ?? 0n) < IMPLICIT_ACCOUNT_MIN_DEPOSIT) return { ok: false, reason: `Creating ${tx.receiverId} needs at least 0.002 NEAR.` };
+      }
+    } else if (!await this.accountExists(tx.receiverId)) {
+      return { ok: false, reason: `Contract ${tx.receiverId} does not exist.` };
+    }
+    const est = estimate ?? await this.estimate(tx, recipientExists);
+    const need = est.deposit + est.fee;
+    if (acct.available < need) return { ok: false, reason: `Insufficient NEAR: need ${need} yocto (deposit + fee), spendable ${acct.available}.` };
+    if (d.kind === "ft-transfer" && d.token && d.amount !== void 0) {
+      const bal = await this.getTokenBalance(d.token);
+      if (bal < d.amount) return { ok: false, reason: `Insufficient ${d.token}: need ${d.amount}, have ${bal}.` };
+      if (d.to && await this.getStorageBalance(d.token, d.to) === null && !d.methods?.includes("storage_deposit")) {
+        return { ok: false, reason: `${d.to} is not registered on ${d.token}; add a storage_deposit action first.` };
+      }
+    }
+    return { ok: true };
+  }
+  // ── Hard checks ─────────────────────────────────────────────────────────────
+  /**
+   * Refuse what cannot be right: a foreign signer or key, no actions, a dangerous
+   * action (unless `allowDangerousActions`), an invalid receiver, prepaid gas over
+   * 300 Tgas, a fee above `transactionMaxFee`.
+   */
+  assertSafe(tx, fee) {
+    if (tx.signerId !== this.address) throw new UnsafeTransactionError("signer-mismatch", `Transaction signer ${tx.signerId} is not this account (${this.address}).`);
+    if (tx.publicKey.keyType !== this.publicKey.keyType || !equalBytes(tx.publicKey.data, this.publicKey.data)) throw new UnsafeTransactionError("public-key-mismatch", "The transaction public key is not this account's key.");
+    if (!tx.actions.length) throw new UnsafeTransactionError("no-actions", "The transaction has no actions.");
+    if (!isValidAccountId(tx.receiverId)) throw new UnsafeTransactionError("invalid-account", `"${tx.receiverId}" is not a valid NEAR account id.`);
+    if (tx.blockHash.length !== 32) throw new UnsafeTransactionError("missing-block-hash", "The transaction has no 32-byte block hash.");
+    if (tx.nonce <= 0n) throw new UnsafeTransactionError("missing-nonce", "The transaction nonce must be positive.");
+    if (!this._config.allowDangerousActions) {
+      const bad = tx.actions.find(isDangerous);
+      if (bad) throw new UnsafeTransactionError("dangerous-action", `Refusing ${Object.keys(bad)[0]}: it changes the account, its keys or its code (set allowDangerousActions to override).`);
+    }
+    let gas = 0n;
+    for (const a of tx.actions) if ("functionCall" in a) gas += a.functionCall.gas ?? 30n * TGAS;
+    if (gas > MAX_GAS) throw new UnsafeTransactionError("gas-limit", `Prepaid gas ${gas} exceeds the 300 Tgas limit.`);
+    const max = this._config.transactionMaxFee;
+    if (fee !== void 0 && max !== void 0 && fee > BigInt(max)) throw new UnsafeTransactionError("fee-limit", `Fee ${fee} exceeds transactionMaxFee ${max}.`);
+  }
+  // ── Describe / receipts / verify ────────────────────────────────────────────
+  /** `describeTransaction` plus the recipient-existence check against the node. */
+  async describeTransactionOnline(tx, ctx = {}) {
+    const offline = describeTransaction(tx, { signerId: this.address, ...ctx });
+    if (ctx.recipientExists !== void 0 || offline.kind !== "near-transfer") return offline;
+    return describeTransaction(tx, { signerId: this.address, ...ctx, recipientExists: await this.accountExists(tx.receiverId) });
+  }
+  /** Status of one of this account's transactions (the `tx` RPC needs the sender). */
+  async getTransactionReceipt(hash) {
+    const o = await this.requireRpc("fetch transaction receipts").txStatus(hash, this.address);
+    if (!o) return void 0;
+    return receiptOf(hash, o);
+  }
+  /** Verify an `ed25519:<base58>` (or bare base58 / hex) signature produced by `sign`. */
+  async verify(message, signature) {
+    try {
+      const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+      return import_ed25519.ed25519.verify(parseSignature(signature), bytes, this.publicKey.data);
+    } catch {
+      return false;
+    }
+  }
+  /** sha256(borsh(tx)) — what gets signed; base58 of it is the transaction hash. */
+  static hashOf(tx) {
+    return (0, import_sha22.sha256)(encodeTransaction(tx));
+  }
+  static txHash(tx) {
+    return bytesToBase58(_WalletAccountReadOnlyNear.hashOf(tx));
+  }
+};
+function receiptOf(hash, o) {
+  const failure = outcomeFailed(o);
+  const pending = o.final_execution_status !== void 0 && /NONE|INCLUDED$/.test(o.final_execution_status) && !failureOf(o.status) && o.status === void 0;
+  return { hash, status: failure ? 0 : 1, ...failure ? { failure } : {}, raw: { ...o, ...pending ? { pending: true } : {} } };
+}
+function parseSignature(signature) {
+  const s = signature.startsWith("ed25519:") ? signature.slice("ed25519:".length) : signature;
+  if (/^(0x)?[0-9a-fA-F]{128}$/.test(s)) {
+    const hex = s.replace(/^0x/, "");
+    return Uint8Array.from(hex.match(/.{2}/g), (b) => parseInt(b, 16));
+  }
+  return base58ToBytes(s, 64);
+}
+function equalBytes(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+
+// src/account.ts
+var import_core3 = require("@anywalletkit/core");
+var WalletAccountNear = class _WalletAccountNear extends WalletAccountReadOnlyNear {
+  /** nonce / block hash come from the node, so building needs the network. */
+  needsNetwork = true;
+  /** Derivation path, or `external` for an external signer. */
+  path;
+  /** The signer that holds the key. */
+  signer;
+  _disposed = false;
+  _readOnly;
+  constructor(signer, publicKey, path, config = {}, accountId) {
+    super(accountId ?? implicitAccountId(publicKey), config, ed25519Key(publicKey));
+    this.signer = (0, import_core3.requireCurve)(signer, "ed25519");
+    this.path = path;
+  }
+  /** Wrap a raw derived key (takes ownership; zeroized on dispose). */
+  static fromPrivateKey(privateKey, publicKey, path, config = {}, accountId) {
+    return new _WalletAccountNear(import_core3.LocalSigner.fromPrivateKey("ed25519", privateKey, publicKey, path), publicKey, path, config, accountId);
+  }
+  /** Account index for the standard m/44'/397'/i' path. */
+  get index() {
+    const m = /^m\/44'\/397'\/(\d+)'$/.exec(this.path);
+    return m ? Number(m[1]) : void 0;
+  }
+  /** The same key bound to a named account (`alice.near`) that lists it as a full-access key. */
+  withAccountId(accountId) {
+    return new _WalletAccountNear(this.signer, this.publicKey.data, this.path, this._config, accountId);
+  }
+  key() {
+    if (this._disposed) throw new import_core3.SignerError("This account has been disposed.");
+  }
+  async signBytes(bytes, context) {
+    this.key();
+    return this.signer.sign(bytes, { scheme: "ed25519", context });
+  }
+  /** Raw ed25519 signature over the message bytes, as NEAR tooling prints it: "ed25519:<base58>". */
+  async sign(message) {
+    const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+    return `ed25519:${bytesToBase58(await this.signBytes(bytes, "near-message"))}`;
+  }
+  /** NEP-413 off-chain message (what NEAR Intents and dApps ask wallets to sign). */
+  async signNep413(payload) {
+    const sig = await this.signBytes(nep413Hash(payload), "near-nep413");
+    return { signature: toBase64(sig), publicKey: publicKeyToString(this.publicKey), accountId: this.address };
+  }
+  /** Sign a fully built transaction. No checks — see `signTransaction`. */
+  async signBuilt(tx) {
+    const sig = await this.signBytes(WalletAccountReadOnlyNear.hashOf(tx), "near-tx");
+    return { transaction: tx, signature: { keyType: "ed25519", data: sig } };
+  }
+  /** Build → hard checks → preflight → fee cap. Shared by sign / send / transfer. */
+  async prepare(tx, maxFee, op) {
+    const built = await this.buildTransaction(tx);
+    this.assertSafe(built);
+    const estimate = await this.estimate(built);
+    this.assertSafe(built, estimate.fee);
+    if (maxFee !== void 0 && estimate.fee > BigInt(maxFee)) throw new Error(`Exceeded maximum fee cost for ${op} operation${op === "transfer" ? "s" : ""}.`);
+    if (this._config.simulate !== false) {
+      const sim = await this.simulateTransaction(built, estimate);
+      if (!sim.ok) throw new SimulationError(sim.reason ?? "unknown");
+    }
+    return { built, estimate };
+  }
+  /** Build, check, preflight and sign; returns the signed transaction as base64 borsh (what `send_tx` takes). */
+  async signTransaction(tx) {
+    this.key();
+    this.requireRpc("sign transactions");
+    const { built } = await this.prepare(tx, this._config.transactionMaxFee, "transaction");
+    return toBase64(encodeSignedTransaction(await this.signBuilt(built)));
+  }
+  async broadcast(signed) {
+    const hash = WalletAccountReadOnlyNear.txHash(signed.transaction);
+    const outcome = await this.requireRpc("broadcast").sendTx(toBase64(encodeSignedTransaction(signed)));
+    const failure = outcomeFailed(outcome);
+    if (failure) throw new Error(`Transaction ${hash} failed on chain: ${failure}`);
+    return outcome.transaction?.hash ?? hash;
+  }
+  /**
+   * Sign and broadcast. Accepts a transaction, or base64 borsh of an unsigned /
+   * already-signed transaction (a signed one is checked, not re-signed).
+   */
+  async sendTransaction(tx) {
+    this.key();
+    this.requireRpc("send transactions");
+    const presigned = typeof tx === "string" ? decodeSigned(tx) : void 0;
+    const { built, estimate } = await this.prepare(tx, this._config.transactionMaxFee, "transaction");
+    const signed = presigned ?? await this.signBuilt(built);
+    return { hash: await this.broadcast(signed), fee: estimate.fee, estimate };
+  }
+  /** Native NEAR (no `token`) or NEP-141 `ft_transfer` (with `storage_deposit` when the recipient needs it). */
+  async transfer(o) {
+    this.key();
+    this.requireRpc("transfer tokens");
+    const { built, estimate } = await this.prepare(await this.transferActions(o), this._config.transferMaxFee, "transfer");
+    return { hash: await this.broadcast(await this.signBuilt(built)), fee: estimate.fee, estimate };
+  }
+  /** The same account as a {@link WalletAccountReadOnlyNear}. */
+  toReadOnlyAccount() {
+    this._readOnly ??= new WalletAccountReadOnlyNear(this.address, this._config, this.publicKey);
+    return this._readOnly;
+  }
+  /** Dispose the signer (zeroizes a local key). Idempotent. */
+  dispose() {
+    this._disposed = true;
+    this.signer.dispose();
+  }
+};
+function decodeSigned(b64) {
+  const { transaction, signature } = decodeAnyTransaction(fromBase64(b64));
+  return signature ? { transaction, signature } : void 0;
+}
+
+// src/manager.ts
+var import_core4 = require("@anywalletkit/core");
+var NEAR_BASE_PATH = "m/44'/397'";
+var WalletManagerNear = class extends import_core4.WalletManager {
+  constructor(seedOrSigner, config = {}) {
+    super(seedOrSigner, config);
+  }
+  async getAccount(index = 0) {
+    return this.getAccountByPath(`${NEAR_BASE_PATH}/${index}'`);
+  }
+  async getAccountByPath(path) {
+    const full = path.startsWith("m/") || path === "external" ? path : `${NEAR_BASE_PATH}/${path}`;
+    if (full !== "external" && !full.split("/").slice(1).every((s) => s.endsWith("'"))) throw new Error("In NEAR, every child path in a derivation path must be hardened.");
+    const cached = this._accounts.get(full);
+    if (cached) return cached;
+    const external = this.externalSigner();
+    if (external) return this.fromSigner(external, full);
+    const signer = import_core4.LocalSigner.leafFromSeed(this.seedBytes(), "ed25519", full);
+    const account = new WalletAccountNear(signer, signer.publicKey, full, this._config);
+    this._accounts.set(full, account);
+    return account;
+  }
+  /** The key of account `index`, bound to a named account that lists it as a full-access key. */
+  async getNamedAccount(accountId, index = 0) {
+    return (await this.getAccount(index)).withAccountId(accountId);
+  }
+  /** Resolve `path` against an injected signer: the signer itself, or a child when it can derive there. */
+  async fromSigner(signer, path) {
+    this.requireSigner("ed25519");
+    let leaf = signer;
+    let key = "external";
+    if ((0, import_core4.isSeedSigner)(signer)) {
+      if (path === signer.path) key = path;
+      else if (path.startsWith(`${signer.path}/`)) {
+        leaf = await (signer.deriveLeaf ?? signer.derive).call(signer, path.slice(signer.path.length + 1));
+        key = path;
+      } else throw new import_core4.SignerError(`The injected signer sits at ${signer.path}; it cannot provide ${path}.`);
+    } else if (path !== `${NEAR_BASE_PATH}/0'` && path !== "external") {
+      throw new import_core4.SignerError(`An external signer has one account; ${path} is not derivable from it.`);
+    }
+    const cached = this._accounts.get(key);
+    if (cached) return cached;
+    const account = new WalletAccountNear(leaf, await leaf.getPublicKey(), key, this._config);
+    this._accounts.set(key, account);
+    return account;
+  }
+  /** A read-only account for any account id, with this manager's config. */
+  getReadOnlyAccount(accountId, publicKey) {
+    return new WalletAccountReadOnlyNear(accountId, this._config, publicKey);
+  }
+  /** NEAR has one protocol gas price (`gas_price` RPC, yoctoNEAR per gas); it can rise ~1%/block, so fast = ×1.1. */
+  async getFeeRates() {
+    const client = createClient(this._config);
+    if (!client) throw new import_core4.NetworkError("The wallet must be connected to a provider to read fee rates.");
+    const price = await new NearRpc(client).gasPrice();
+    return { slow: price, normal: price, fast: price * 11n / 10n };
+  }
+};
+
+// 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 utf82 = (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(utf82(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=index.cjs.map