@anywalletkit/wallet-near 0.0.0-stage → 0.1.2

package/dist/index.js

@@ -0,0 +1,1097 @@
+import {
+  CAIP2,
+  FT_TRANSFER_GAS,
+  HistoryUnavailableError,
+  IMPLICIT_ACCOUNT_MIN_DEPOSIT,
+  MAX_GAS,
+  NearRpc,
+  NearRpcError,
+  ONE_YOCTO,
+  STORAGE_DEPOSIT_GAS,
+  STORAGE_PRICE_PER_BYTE,
+  SimulationError,
+  TGAS,
+  UnsafeTransactionError,
+  YOCTO,
+  createClient,
+  createNearHistory,
+  decodeCursor,
+  decodeFunctionCallArgs,
+  encodeCursor,
+  failureOf,
+  fromBase64,
+  mapNearblocksGroup,
+  mapNearblocksTxn,
+  mapRpcTxStatus,
+  nearExplorerTxUrl,
+  outcomeFailed,
+  parseJsonPreservingBigInts,
+  toBase64
+} from "./chunk-2GH6U3LB.js";
+
+// src/address.ts
+import { base58 } from "@scure/base";
+import { bytesToHex, hexToBytes } from "@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 bytesToHex(publicKey);
+}
+function publicKeyToString(k) {
+  return `${k.keyType}:${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 = 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 hexToBytes(accountId);
+}
+function base58ToBytes(s, length) {
+  const b = base58.decode(s);
+  if (length !== void 0 && b.length !== length) throw new RangeError(`expected ${length} bytes, got ${b.length}`);
+  return b;
+}
+var bytesToBase58 = (b) => 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/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
+import { sha256 } from "@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 sha256(nep413Bytes(p));
+}
+
+// src/read-only-account.ts
+import { NetworkError } from "@anywalletkit/core";
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { sha256 as sha2562 } from "@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 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 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 sha2562(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
+import { LocalSigner, SignerError, requireCurve } from "@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 = 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(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 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
+import { LocalSigner as LocalSigner2, NetworkError as NetworkError2, SignerError as SignerError2, WalletManager, isSeedSigner } from "@anywalletkit/core";
+var NEAR_BASE_PATH = "m/44'/397'";
+var WalletManagerNear = class extends 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 = LocalSigner2.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 (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 SignerError2(`The injected signer sits at ${signer.path}; it cannot provide ${path}.`);
+    } else if (path !== `${NEAR_BASE_PATH}/0'` && path !== "external") {
+      throw new SignerError2(`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 NetworkError2("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 };
+  }
+};
+export {
+  ACTION_TAG,
+  BorshReader,
+  BorshWriter,
+  CAIP2,
+  DANGEROUS_ACTIONS,
+  FT_TRANSFER_GAS,
+  HistoryUnavailableError,
+  IMPLICIT_ACCOUNT_MIN_DEPOSIT,
+  MAX_GAS,
+  NEAR_BASE_PATH,
+  NEP413_PREFIX,
+  NearRpc,
+  NearRpcError,
+  ONE_YOCTO,
+  STORAGE_DEPOSIT_GAS,
+  STORAGE_PRICE_PER_BYTE,
+  SimulationError,
+  TGAS,
+  UnsafeTransactionError,
+  WalletAccountNear,
+  WalletAccountReadOnlyNear,
+  WalletManagerNear,
+  YOCTO,
+  actionKey,
+  argsBytes,
+  base58ToBytes,
+  bytesToBase58,
+  createClient,
+  createNearHistory,
+  decodeAnyTransaction,
+  decodeFunctionCallArgs,
+  decodeCursor as decodeHistoryCursor,
+  decodeSignedTransaction,
+  decodeTransaction,
+  WalletManagerNear as default,
+  describeTransaction,
+  ed25519Key,
+  encodeCursor as encodeHistoryCursor,
+  encodeSignedTransaction,
+  encodeTransaction,
+  failureOf,
+  fromBase64,
+  implicitAccountId,
+  isDangerous,
+  isImplicitAccountId,
+  isValidAccountId,
+  mapNearblocksGroup,
+  mapNearblocksTxn,
+  mapRpcTxStatus,
+  nearExplorerTxUrl,
+  nep413Bytes,
+  nep413Hash,
+  outcomeFailed,
+  parseJsonPreservingBigInts,
+  parsePublicKey,
+  parseSignature,
+  publicKeyOfImplicit,
+  publicKeyToString,
+  readAction,
+  readPublicKey,
+  readSignature,
+  receiptOf,
+  toBase64,
+  writeAction,
+  writePublicKey,
+  writeSignature
+};
+//# sourceMappingURL=index.js.map