@fastnear/utils 0.6.2 → 0.7.0

package/dist/cjs/misc.cjs

@@ -0,0 +1,187 @@
+/* ⋈ 🏃🏻💨 FastNEAR Utils - CJS (@fastnear/utils version 0.6.3) */
+/* https://www.npmjs.com/package/@fastnear/utils/v/0.6.3 */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var misc_exports = {};
+__export(misc_exports, {
+  base64ToBytes: () => base64ToBytes,
+  bytesToBase64: () => bytesToBase64,
+  canSignWithLAK: () => canSignWithLAK,
+  convertUnit: () => convertUnit,
+  deepCopy: () => deepCopy,
+  fromBase58: () => import_base58_js.base58_to_binary,
+  fromBase64: () => fromBase64,
+  fromHex: () => fromHex,
+  lsGet: () => lsGet,
+  lsSet: () => lsSet,
+  parseJsonFromBytes: () => parseJsonFromBytes,
+  toBase58: () => import_base58_js.binary_to_base58,
+  toBase64: () => toBase64,
+  toHex: () => toHex,
+  tryParseJson: () => tryParseJson
+});
+module.exports = __toCommonJS(misc_exports);
+var import_base58_js = require("base58-js");
+var import_big = __toESM(require("big.js"), 1);
+var import_js_base64 = require("js-base64");
+var import_storage = require("./storage.js");
+function toHex(data) {
+  return Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+__name(toHex, "toHex");
+function fromHex(hex) {
+  if (hex.length % 2) throw new Error("Hex string must be even length");
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+__name(fromHex, "fromHex");
+function base64ToBytes(b64Val) {
+  return (0, import_js_base64.toUint8Array)(b64Val);
+}
+__name(base64ToBytes, "base64ToBytes");
+function bytesToBase64(bytesArr) {
+  return (0, import_js_base64.fromUint8Array)(bytesArr);
+}
+__name(bytesToBase64, "bytesToBase64");
+function toBase64(strVal) {
+  try {
+    return (0, import_js_base64.encode)(strVal);
+  } catch (e) {
+    console.error("Issue base64 encoding", e);
+    return null;
+  }
+}
+__name(toBase64, "toBase64");
+function fromBase64(strVal) {
+  try {
+    return (0, import_js_base64.decode)(strVal);
+  } catch (e) {
+    console.error("Issue base64 decoding", e);
+    return null;
+  }
+}
+__name(fromBase64, "fromBase64");
+function convertUnit(s, ...args) {
+  if (Array.isArray(s)) {
+    s = s.reduce((acc, part, i) => {
+      return acc + (args[i - 1] ?? "") + part;
+    });
+  }
+  if (typeof s == "string") {
+    const match = s.match(/([0-9.,_]+)\s*([a-zA-Z]+)?/);
+    if (match) {
+      const amount = match[1].replace(/[_,]/g, "");
+      const unitPart = match[2];
+      if (unitPart) {
+        switch (unitPart.toLowerCase()) {
+          case "near":
+            return (0, import_big.default)(amount).mul((0, import_big.default)(10).pow(24)).toFixed(0);
+          case "tgas":
+            return (0, import_big.default)(amount).mul((0, import_big.default)(10).pow(12)).toFixed(0);
+          case "ggas":
+            return (0, import_big.default)(amount).mul((0, import_big.default)(10).pow(9)).toFixed(0);
+          case "gas":
+          case "yoctonear":
+            return (0, import_big.default)(amount).toFixed(0);
+          default:
+            throw new Error(`Unknown unit: ${unitPart}`);
+        }
+      } else {
+        return (0, import_big.default)(amount).toFixed(0);
+      }
+    }
+  }
+  return (0, import_big.default)(`${s}`).toFixed(0);
+}
+__name(convertUnit, "convertUnit");
+function lsSet(key, value) {
+  import_storage.storage.set(key, value);
+}
+__name(lsSet, "lsSet");
+function lsGet(key) {
+  return import_storage.storage.get(key);
+}
+__name(lsGet, "lsGet");
+function deepCopy(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+__name(deepCopy, "deepCopy");
+function tryParseJson(...args) {
+  try {
+    return JSON.parse(args[0]);
+  } catch {
+    if (args.length > 1) {
+      return args[1];
+    }
+    return args[0];
+  }
+}
+__name(tryParseJson, "tryParseJson");
+function parseJsonFromBytes(bytes) {
+  try {
+    const decoder = new TextDecoder();
+    return JSON.parse(
+      decoder.decode(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes))
+    );
+  } catch (e) {
+    try {
+      return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+    } catch (e2) {
+      return bytes;
+    }
+  }
+}
+__name(parseJsonFromBytes, "parseJsonFromBytes");
+function canSignWithLAK(actions) {
+  return actions.length === 1 && actions[0].type === "FunctionCall" && (0, import_big.default)(actions[0]?.deposit ?? "0").eq(0);
+}
+__name(canSignWithLAK, "canSignWithLAK");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base64ToBytes,
+  bytesToBase64,
+  canSignWithLAK,
+  convertUnit,
+  deepCopy,
+  fromBase58,
+  fromBase64,
+  fromHex,
+  lsGet,
+  lsSet,
+  parseJsonFromBytes,
+  toBase58,
+  toBase64,
+  toHex,
+  tryParseJson
+});
+//# sourceMappingURL=misc.cjs.map

package/dist/cjs/misc.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/misc.ts"],"sourcesContent":["import {\n  binary_to_base58 as toBase58,\n  base58_to_binary as fromBase58,\n} from \"base58-js\";\nimport Big from \"big.js\";\nimport {\n  encode as JsBase64Encode,\n  decode as JsBase64Decode,\n  fromUint8Array as JsBase64FromUint8Array,\n  toUint8Array as JsBase64ToUint8Array\n} from 'js-base64';\nimport {Hex} from \"@noble/curves/abstract/utils\";\nimport { storage } from \"./storage.js\";\n\nexport { toBase58, fromBase58 };\n\nexport function toHex(data: Uint8Array): string {\n  return Array.from(data)\n    .map(b => b.toString(16).padStart(2, '0'))\n    .join('');\n}\n\nexport function fromHex(hex: string): Uint8Array {\n  if (hex.length % 2) throw new Error('Hex string must be even length');\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    bytes[i/2] = parseInt(hex.slice(i, i + 2), 16);\n  }\n  return bytes;\n}\n\nexport function base64ToBytes(b64Val: string): Uint8Array {\n  return JsBase64ToUint8Array(b64Val);\n}\n\nexport function bytesToBase64(bytesArr: Uint8Array): string {\n  return JsBase64FromUint8Array(bytesArr);\n}\n\nexport function toBase64(strVal: string) {\n  try {\n    return JsBase64Encode(strVal);\n  } catch (e) {\n    console.error('Issue base64 encoding', e);\n    return null;\n  }\n}\n\nexport function fromBase64(strVal: string) {\n  try {\n    return JsBase64Decode(strVal);\n  } catch (e) {\n    console.error('Issue base64 decoding', e);\n    return null;\n  }\n}\n\nexport function convertUnit(s: string | TemplateStringsArray, ...args: any[]): string {\n  // Reconstruct raw string from template literal\n  if (Array.isArray(s)) {\n    s = s.reduce((acc, part, i) => {\n      return acc + (args[i - 1] ?? \"\") + part;\n    });\n  }\n  // Convert from `100 NEAR` into yoctoNear\n  if (typeof s == \"string\") {\n    const match = s.match(/([0-9.,_]+)\\s*([a-zA-Z]+)?/);\n    if (match) {\n      const amount = match[1].replace(/[_,]/g, \"\");\n      const unitPart = match[2];\n      if (unitPart) {\n        switch (unitPart.toLowerCase()) {\n          case \"near\":\n            return Big(amount).mul(Big(10).pow(24)).toFixed(0);\n          case \"tgas\":\n            return Big(amount).mul(Big(10).pow(12)).toFixed(0);\n          case \"ggas\":\n            return Big(amount).mul(Big(10).pow(9)).toFixed(0);\n          case \"gas\":\n          case \"yoctonear\":\n            return Big(amount).toFixed(0);\n          default:\n            throw new Error(`Unknown unit: ${unitPart}`);\n        }\n      } else {\n        return Big(amount).toFixed(0);\n      }\n    }\n  }\n  return Big(`${s}`).toFixed(0);\n}\n\nexport function lsSet(key: string, value: any) {\n  storage.set(key, value);\n}\n\nexport function lsGet(key: string): any {\n  return storage.get(key);\n}\n\n// export function lsSet(key, value) {\n//   if (value === null || value === undefined) {\n//     localStorage.removeItem(LsPrefix + key);\n//   } else {\n//     localStorage.setItem(LsPrefix + key, JSON.stringify(value));\n//   }\n// }\n//\n// export function lsGet(key) {\n//   const value = localStorage.getItem(LsPrefix + key);\n//   return tryParseJson(value, null);\n// }\n\nexport function deepCopy(obj) {\n  return JSON.parse(JSON.stringify(obj));\n}\n\nexport function tryParseJson(...args) {\n  try {\n    return JSON.parse(args[0]);\n  } catch {\n    if (args.length > 1) {\n      return args[1];\n    }\n    return args[0];\n  }\n}\n\nexport function parseJsonFromBytes(bytes: Uint8Array) {\n  try {\n    const decoder = new TextDecoder();\n    return JSON.parse(\n      decoder.decode(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes))\n    );\n  } catch (e) {\n    try {\n      return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);\n    } catch (e) {\n      return bytes;\n    }\n  }\n}\n\nexport function canSignWithLAK(actions) {\n  return (\n    actions.length === 1 &&\n    actions[0].type === \"FunctionCall\" &&\n    Big(actions[0]?.deposit ?? \"0\").eq(0)\n  );\n}\n"],"mappings":"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","names":["fromBase58","toBase58","JsBase64ToUint8Array","JsBase64FromUint8Array","JsBase64Encode","JsBase64Decode","Big","e"]}

package/dist/cjs/storage.cjs

@@ -0,0 +1,69 @@
+/* ⋈ 🏃🏻💨 FastNEAR Utils - CJS (@fastnear/utils version 0.6.3) */
+/* https://www.npmjs.com/package/@fastnear/utils/v/0.6.3 */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var storage_exports = {};
+__export(storage_exports, {
+  LsPrefix: () => LsPrefix,
+  createDefaultStorage: () => createDefaultStorage,
+  memoryStore: () => memoryStore,
+  storage: () => storage
+});
+module.exports = __toCommonJS(storage_exports);
+const LsPrefix = "__fastnear_";
+const createDefaultStorage = /* @__PURE__ */ __name(() => typeof localStorage !== "undefined" ? localStorage : {
+  getItem: /* @__PURE__ */ __name((key) => memoryStore.get(key) || null, "getItem"),
+  setItem: /* @__PURE__ */ __name((key, value) => memoryStore.set(key, value), "setItem"),
+  removeItem: /* @__PURE__ */ __name((key) => memoryStore.delete(key), "removeItem"),
+  clear: /* @__PURE__ */ __name(() => memoryStore.clear(), "clear")
+}, "createDefaultStorage");
+const memoryStore = /* @__PURE__ */ new Map();
+let storageBackend = createDefaultStorage();
+const storage = {
+  setBackend: /* @__PURE__ */ __name((customBackend) => {
+    storageBackend = customBackend;
+  }, "setBackend"),
+  set: /* @__PURE__ */ __name((key, value) => {
+    if (value === null || value === void 0) {
+      storageBackend.removeItem(LsPrefix + key);
+    } else {
+      storageBackend.setItem(LsPrefix + key, JSON.stringify(value));
+    }
+  }, "set"),
+  get: /* @__PURE__ */ __name((key) => {
+    const value = storageBackend.getItem(LsPrefix + key);
+    if (value === null) return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }, "get"),
+  remove: /* @__PURE__ */ __name((key) => storageBackend.removeItem(key), "remove"),
+  clear: /* @__PURE__ */ __name(() => storageBackend.clear(), "clear")
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LsPrefix,
+  createDefaultStorage,
+  memoryStore,
+  storage
+});
+//# sourceMappingURL=storage.cjs.map

package/dist/cjs/storage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/storage.ts"],"sourcesContent":["export const LsPrefix = \"__fastnear_\";\n\nexport interface StorageBackend {\n  getItem(key: string): string | null;\n  setItem(key: string, value: string): void;\n  removeItem(key: string): void;\n  clear(): void;\n}\n\n// Default: Use `localStorage` if available, otherwise an in-memory fallback\nexport const createDefaultStorage = (): StorageBackend =>\n  typeof localStorage !== \"undefined\"\n    ? localStorage\n    : {\n      getItem: (key) => memoryStore.get(key) || null,\n      setItem: (key, value) => memoryStore.set(key, value),\n      removeItem: (key) => memoryStore.delete(key),\n      clear: () => memoryStore.clear(),\n    };\n\nexport const memoryStore = new Map<string, string>(); // Internal memory storage\n\nlet storageBackend: StorageBackend = createDefaultStorage();\n\n// Functional storage module\nexport const storage = {\n  setBackend: (customBackend: StorageBackend) => {\n    storageBackend = customBackend;\n  },\n\n  set: (key: string, value: any) => {\n    if (value === null || value === undefined) {\n      storageBackend.removeItem(LsPrefix + key);\n    } else {\n      storageBackend.setItem(LsPrefix + key, JSON.stringify(value));\n    }\n  },\n\n  get: (key: string): any => {\n    const value = storageBackend.getItem(LsPrefix + key);\n    if (value === null) return null;\n    try {\n      return JSON.parse(value);\n    } catch {\n      return value; // Return raw string if not JSON\n    }\n  },\n\n  remove: (key: string) => storageBackend.removeItem(key),\n  clear: () => storageBackend.clear(),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,WAAW;AAUjB,MAAM,uBAAuB,6BAClC,OAAO,iBAAiB,cACpB,eACA;AAAA,EACA,SAAS,wBAAC,QAAQ,YAAY,IAAI,GAAG,KAAK,MAAjC;AAAA,EACT,SAAS,wBAAC,KAAK,UAAU,YAAY,IAAI,KAAK,KAAK,GAA1C;AAAA,EACT,YAAY,wBAAC,QAAQ,YAAY,OAAO,GAAG,GAA/B;AAAA,EACZ,OAAO,6BAAM,YAAY,MAAM,GAAxB;AACT,GARgC;AAU7B,MAAM,cAAc,oBAAI,IAAoB;AAEnD,IAAI,iBAAiC,qBAAqB;AAGnD,MAAM,UAAU;AAAA,EACrB,YAAY,wBAAC,kBAAkC;AAC7C,qBAAiB;AAAA,EACnB,GAFY;AAAA,EAIZ,KAAK,wBAAC,KAAa,UAAe;AAChC,QAAI,UAAU,QAAQ,UAAU,QAAW;AACzC,qBAAe,WAAW,WAAW,GAAG;AAAA,IAC1C,OAAO;AACL,qBAAe,QAAQ,WAAW,KAAK,KAAK,UAAU,KAAK,CAAC;AAAA,IAC9D;AAAA,EACF,GANK;AAAA,EAQL,KAAK,wBAAC,QAAqB;AACzB,UAAM,QAAQ,eAAe,QAAQ,WAAW,GAAG;AACnD,QAAI,UAAU,KAAM,QAAO;AAC3B,QAAI;AACF,aAAO,KAAK,MAAM,KAAK;AAAA,IACzB,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF,GARK;AAAA,EAUL,QAAQ,wBAAC,QAAgB,eAAe,WAAW,GAAG,GAA9C;AAAA,EACR,OAAO,6BAAM,eAAe,MAAM,GAA3B;AACT;","names":[]}

package/dist/cjs/transaction.cjs

@@ -0,0 +1,198 @@
+/* ⋈ 🏃🏻💨 FastNEAR Utils - CJS (@fastnear/utils version 0.6.3) */
+/* https://www.npmjs.com/package/@fastnear/utils/v/0.6.3 */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var transaction_exports = {};
+__export(transaction_exports, {
+  SCHEMA: () => SCHEMA,
+  mapAction: () => mapAction,
+  mapTransaction: () => mapTransaction,
+  serializeSignedTransaction: () => serializeSignedTransaction,
+  serializeTransaction: () => serializeTransaction,
+  txToJson: () => txToJson,
+  txToJsonStringified: () => txToJsonStringified
+});
+module.exports = __toCommonJS(transaction_exports);
+var import_borsh = require("borsh");
+var import_crypto = require("./crypto.js");
+var import_misc = require("./misc.js");
+var import_borsh_schema = require("@fastnear/borsh-schema");
+const txToJson = /* @__PURE__ */ __name((tx) => {
+  return JSON.parse(JSON.stringify(
+    tx,
+    (key, value) => typeof value === "bigint" ? value.toString() : value
+  ));
+}, "txToJson");
+const txToJsonStringified = /* @__PURE__ */ __name((tx) => {
+  return JSON.stringify(txToJson(tx));
+}, "txToJsonStringified");
+function mapTransaction(jsonTransaction) {
+  return {
+    signerId: jsonTransaction.signerId,
+    publicKey: {
+      ed25519Key: {
+        data: (0, import_crypto.keyFromString)(jsonTransaction.publicKey)
+      }
+    },
+    nonce: BigInt(jsonTransaction.nonce),
+    receiverId: jsonTransaction.receiverId,
+    blockHash: (0, import_misc.fromBase58)(jsonTransaction.blockHash),
+    actions: jsonTransaction.actions.map(mapAction)
+  };
+}
+__name(mapTransaction, "mapTransaction");
+function serializeTransaction(jsonTransaction) {
+  console.log("fastnear: serializing transaction");
+  const transaction = mapTransaction(jsonTransaction);
+  console.log("fastnear: mapped transaction for borsh:", transaction);
+  return (0, import_borsh.serialize)(SCHEMA.Transaction, transaction);
+}
+__name(serializeTransaction, "serializeTransaction");
+function serializeSignedTransaction(jsonTransaction, signature) {
+  console.log("fastnear: Serializing Signed Transaction", jsonTransaction);
+  console.log("fastnear: signature", signature);
+  console.log("fastnear: signature length", (0, import_misc.fromBase58)(signature).length);
+  const mappedSignedTx = mapTransaction(jsonTransaction);
+  console.log("fastnear: mapped (for borsh schema) signed transaction", mappedSignedTx);
+  const plainSignedTransaction = {
+    transaction: mappedSignedTx,
+    signature: {
+      ed25519Signature: {
+        data: (0, import_misc.fromBase58)(signature)
+      }
+    }
+  };
+  const borshSignedTx = (0, import_borsh.serialize)(SCHEMA.SignedTransaction, plainSignedTransaction, true);
+  console.log("fastnear: borsh-serialized signed transaction:", borshSignedTx);
+  return borshSignedTx;
+}
+__name(serializeSignedTransaction, "serializeSignedTransaction");
+function mapAction(action) {
+  switch (action.type) {
+    case "CreateAccount": {
+      return {
+        createAccount: {}
+      };
+    }
+    case "DeployContract": {
+      return {
+        deployContract: {
+          code: (0, import_misc.fromBase64)(action.codeBase64)
+        }
+      };
+    }
+    case "FunctionCall": {
+      const argsAsString = JSON.stringify(action.args);
+      const argsEncoded = new TextEncoder().encode(argsAsString);
+      return {
+        functionCall: {
+          methodName: action.methodName,
+          args: argsEncoded,
+          gas: BigInt(action.gas),
+          deposit: BigInt(action.deposit)
+        }
+      };
+    }
+    case "Transfer": {
+      return {
+        transfer: {
+          deposit: BigInt(action.deposit)
+        }
+      };
+    }
+    case "Stake": {
+      return {
+        stake: {
+          stake: BigInt(action.stake),
+          publicKey: {
+            ed25519Key: {
+              data: (0, import_crypto.keyFromString)(action.publicKey)
+            }
+          }
+        }
+      };
+    }
+    case "AddKey": {
+      return {
+        addKey: {
+          publicKey: {
+            ed25519Key: {
+              data: (0, import_crypto.keyFromString)(action.publicKey)
+            }
+          },
+          accessKey: {
+            nonce: BigInt(action.accessKey.nonce),
+            permission: action.accessKey.permission === "FullAccess" ? { fullAccess: {} } : {
+              functionCall: {
+                allowance: action.accessKey.allowance ? BigInt(action.accessKey.allowance) : null,
+                receiverId: action.accessKey.receiverId,
+                methodNames: action.accessKey.methodNames
+              }
+            }
+          }
+        }
+      };
+    }
+    case "DeleteKey": {
+      return {
+        deleteKey: {
+          publicKey: {
+            ed25519Key: {
+              data: (0, import_crypto.keyFromString)(action.publicKey)
+            }
+          }
+        }
+      };
+    }
+    case "DeleteAccount": {
+      return {
+        deleteAccount: {
+          beneficiaryId: action.beneficiaryId
+        }
+      };
+    }
+    case "SignedDelegate": {
+      return {
+        signedDelegate: {
+          delegateAction: mapAction(action.delegateAction),
+          signature: {
+            ed25519Signature: (0, import_misc.fromBase58)(action.signature)
+          }
+        }
+      };
+    }
+    default: {
+      throw new Error("Not implemented action: " + action.type);
+    }
+  }
+}
+__name(mapAction, "mapAction");
+const SCHEMA = (0, import_borsh_schema.getBorshSchema)();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SCHEMA,
+  mapAction,
+  mapTransaction,
+  serializeSignedTransaction,
+  serializeTransaction,
+  txToJson,
+  txToJsonStringified
+});
+//# sourceMappingURL=transaction.cjs.map

package/dist/cjs/transaction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transaction.ts"],"sourcesContent":["import { serialize as borshSerialize, deserialize as borshDeserialize, Schema } from \"borsh\";\nimport { keyFromString } from \"./crypto.js\";\nimport { fromBase58, fromBase64, toBase64 } from \"./misc.js\";\nimport { getBorshSchema } from \"@fastnear/borsh-schema\";\n\nexport interface PlainTransaction {\n  signerId: string;\n  publicKey: string;\n  nonce: string | bigint | number;\n  receiverId: string;\n  blockHash: string;\n  actions: Array<any>;\n}\n\nexport interface PlainSignedTransaction {\n  transaction: object;\n  signature: object;\n}\n\n// Function to return a JSON-ready version of the transaction\nexport const txToJson = (tx: PlainTransaction): Record<string, any> => {\n  return JSON.parse(JSON.stringify(tx, (key, value) =>\n    typeof value === 'bigint' ? value.toString() : value\n  ));\n};\n\n// dude let's make this better. head just couldn't find a good name\nexport const txToJsonStringified = (tx: PlainTransaction): string => {\n  return JSON.stringify(txToJson(tx));\n}\n\nexport function mapTransaction(jsonTransaction: PlainTransaction) {\n  return {\n    signerId: jsonTransaction.signerId,\n    publicKey: {\n      ed25519Key: {\n        data: keyFromString(jsonTransaction.publicKey)\n      }\n    },\n    nonce: BigInt(jsonTransaction.nonce),\n    receiverId: jsonTransaction.receiverId,\n    blockHash: fromBase58(jsonTransaction.blockHash),\n    actions: jsonTransaction.actions.map(mapAction)\n  };\n}\n\nexport function serializeTransaction(jsonTransaction: PlainTransaction) {\n  console.log(\"fastnear: serializing transaction\");\n\n  const transaction = mapTransaction(jsonTransaction);\n  console.log(\"fastnear: mapped transaction for borsh:\", transaction);\n\n  return borshSerialize(SCHEMA.Transaction, transaction);\n}\n\nexport function serializeSignedTransaction(jsonTransaction: PlainTransaction, signature) {\n  console.log(\"fastnear: Serializing Signed Transaction\", jsonTransaction);\n  console.log('fastnear: signature', signature)\n  console.log('fastnear: signature length', fromBase58(signature).length)\n\n  const mappedSignedTx = mapTransaction(jsonTransaction)\n  console.log('fastnear: mapped (for borsh schema) signed transaction', mappedSignedTx)\n\n  const plainSignedTransaction: PlainSignedTransaction = {\n    transaction: mappedSignedTx,\n    signature: {\n      ed25519Signature: {\n        data: fromBase58(signature),\n      },\n    },\n  };\n\n  const borshSignedTx = borshSerialize(SCHEMA.SignedTransaction, plainSignedTransaction, true);\n  console.log('fastnear: borsh-serialized signed transaction:', borshSignedTx);\n\n  return borshSignedTx;\n}\n\nexport function mapAction(action: any): object {\n  switch (action.type) {\n    case \"CreateAccount\": {\n      return {\n        createAccount: {},\n      };\n    }\n    case \"DeployContract\": {\n      return {\n        deployContract: {\n          code: fromBase64(action.codeBase64),\n        },\n      };\n    }\n    case \"FunctionCall\": {\n      // turn JS object into json string\n      const argsAsString = JSON.stringify(action.args)\n      // an alternative to using NodeJS Buffer, TextEncoder can help but is limited\n      const argsEncoded = new TextEncoder().encode(argsAsString)\n\n      return {\n        functionCall: {\n          methodName: action.methodName,\n          args: argsEncoded,\n          gas: BigInt(action.gas),\n          deposit: BigInt(action.deposit),\n        },\n      };\n    }\n    case \"Transfer\": {\n      return {\n        transfer: {\n          deposit: BigInt(action.deposit),\n        },\n      };\n    }\n    case \"Stake\": {\n      return {\n        stake: {\n          stake: BigInt(action.stake),\n          publicKey: {\n            ed25519Key: {\n              data: keyFromString(action.publicKey),\n            },\n          },\n        },\n      };\n    }\n    case \"AddKey\": {\n      return {\n        addKey: {\n          publicKey: {\n            ed25519Key: {\n              data: keyFromString(action.publicKey),\n            },\n          },\n          accessKey: {\n            nonce: BigInt(action.accessKey.nonce),\n            permission:\n              action.accessKey.permission === \"FullAccess\"\n                ? { fullAccess: {} }\n                : {\n                  functionCall: {\n                    allowance: action.accessKey.allowance\n                      ? BigInt(action.accessKey.allowance)\n                      : null,\n                    receiverId: action.accessKey.receiverId,\n                    methodNames: action.accessKey.methodNames,\n                  },\n                },\n          },\n        },\n      };\n    }\n    case \"DeleteKey\": {\n      return {\n        deleteKey: {\n          publicKey: {\n            ed25519Key: {\n              data: keyFromString(action.publicKey),\n            },\n          },\n        },\n      };\n    }\n    case \"DeleteAccount\": {\n      return {\n        deleteAccount: {\n          beneficiaryId: action.beneficiaryId,\n        },\n      };\n    }\n    case \"SignedDelegate\": {\n      return {\n        signedDelegate: {\n          delegateAction: mapAction(action.delegateAction),\n          signature: {\n            ed25519Signature: fromBase58(action.signature),\n          },\n        },\n      };\n    }\n    default: {\n      throw new Error(\"Not implemented action: \" + action.type);\n    }\n  }\n}\n\nexport const SCHEMA = getBorshSchema();\n"],"mappings":"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","names":["borshSerialize"]}

package/dist/esm/crypto.js

@@ -0,0 +1,52 @@
+/* ⋈ 🏃🏻💨 FastNEAR Utils - ESM (@fastnear/utils version 0.6.3) */
+/* https://www.npmjs.com/package/@fastnear/utils/v/0.6.3 */
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ed25519 } from "@noble/curves/ed25519";
+import { sha256 } from "@noble/hashes/sha2";
+import { fromBase58, toBase58 } from "./misc.js";
+const keyFromString = /* @__PURE__ */ __name((key) => fromBase58(
+  key.includes(":") ? (() => {
+    const [curve, keyPart] = key.split(":");
+    if (curve !== "ed25519") {
+      throw new Error(`Unsupported curve: ${curve}`);
+    }
+    return keyPart;
+  })() : key
+), "keyFromString");
+const keyToString = /* @__PURE__ */ __name((key) => `ed25519:${toBase58(key)}`, "keyToString");
+function publicKeyFromPrivate(privateKey) {
+  const secret = keyFromString(privateKey).slice(0, 32);
+  const publicKey = ed25519.getPublicKey(secret);
+  return keyToString(publicKey);
+}
+__name(publicKeyFromPrivate, "publicKeyFromPrivate");
+function privateKeyFromRandom() {
+  const privateKey = crypto.getRandomValues(new Uint8Array(64));
+  return keyToString(privateKey);
+}
+__name(privateKeyFromRandom, "privateKeyFromRandom");
+function signHash(hashBytes, privateKey, opts) {
+  const secret = keyFromString(privateKey).slice(0, 32);
+  const signature = ed25519.sign(hashBytes, secret);
+  if (opts?.returnBase58) {
+    return toBase58(signature);
+  }
+  return signature;
+}
+__name(signHash, "signHash");
+function signBytes(bytes, privateKey) {
+  const hash = sha256(bytes);
+  return signHash(hash, privateKey);
+}
+__name(signBytes, "signBytes");
+export {
+  keyFromString,
+  keyToString,
+  privateKeyFromRandom,
+  publicKeyFromPrivate,
+  sha256,
+  signBytes,
+  signHash
+};
+//# sourceMappingURL=crypto.js.map

package/dist/esm/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/crypto.ts"],"sourcesContent":["import { ed25519 } from \"@noble/curves/ed25519\";\nimport { sha256 } from \"@noble/hashes/sha2\";\nimport { fromBase58, toBase58 } from \"./misc.js\";\nimport {Hex} from \"@noble/curves/abstract/utils\";\n\nexport { sha256 };\n\nexport const keyFromString = (key) =>\n  fromBase58(\n    key.includes(\":\")\n      ? (() => {\n          const [curve, keyPart] = key.split(\":\");\n          if (curve !== \"ed25519\") {\n            throw new Error(`Unsupported curve: ${curve}`);\n          }\n          return keyPart;\n        })()\n      : key,\n  );\n\nexport const keyToString = (key: Uint8Array) => `ed25519:${toBase58(key)}`;\n\nexport function publicKeyFromPrivate(privateKey: string) {\n  const secret = keyFromString(privateKey).slice(0, 32);\n  const publicKey = ed25519.getPublicKey(secret);\n  return keyToString(publicKey);\n}\n\nexport function privateKeyFromRandom() {\n  const privateKey = crypto.getRandomValues(new Uint8Array(64));\n  return keyToString(privateKey);\n}\n\nexport function signHash(hashBytes: Uint8Array, privateKey: string, opts?: any): Hex {\n  const secret = keyFromString(privateKey).slice(0, 32);\n  const signature = ed25519.sign(hashBytes, secret);\n\n  if (opts?.returnBase58) {\n    return toBase58(signature);\n  }\n\n  return signature;\n}\n\nexport function signBytes(bytes: Uint8Array, privateKey: string) {\n  const hash = sha256(bytes);\n  return signHash(hash, privateKey);\n}\n"],"mappings":";;;;AAAA,SAAS,eAAe;AACxB,SAAS,cAAc;AACvB,SAAS,YAAY,gBAAgB;AAK9B,MAAM,gBAAgB,wBAAC,QAC5B;AAAA,EACE,IAAI,SAAS,GAAG,KACX,MAAM;AACL,UAAM,CAAC,OAAO,OAAO,IAAI,IAAI,MAAM,GAAG;AACtC,QAAI,UAAU,WAAW;AACvB,YAAM,IAAI,MAAM,sBAAsB,KAAK,EAAE;AAAA,IAC/C;AACA,WAAO;AAAA,EACT,GAAG,IACH;AACN,GAX2B;AAatB,MAAM,cAAc,wBAAC,QAAoB,WAAW,SAAS,GAAG,CAAC,IAA7C;AAEpB,SAAS,qBAAqB,YAAoB;AACvD,QAAM,SAAS,cAAc,UAAU,EAAE,MAAM,GAAG,EAAE;AACpD,QAAM,YAAY,QAAQ,aAAa,MAAM;AAC7C,SAAO,YAAY,SAAS;AAC9B;AAJgB;AAMT,SAAS,uBAAuB;AACrC,QAAM,aAAa,OAAO,gBAAgB,IAAI,WAAW,EAAE,CAAC;AAC5D,SAAO,YAAY,UAAU;AAC/B;AAHgB;AAKT,SAAS,SAAS,WAAuB,YAAoB,MAAiB;AACnF,QAAM,SAAS,cAAc,UAAU,EAAE,MAAM,GAAG,EAAE;AACpD,QAAM,YAAY,QAAQ,KAAK,WAAW,MAAM;AAEhD,MAAI,MAAM,cAAc;AACtB,WAAO,SAAS,SAAS;AAAA,EAC3B;AAEA,SAAO;AACT;AATgB;AAWT,SAAS,UAAU,OAAmB,YAAoB;AAC/D,QAAM,OAAO,OAAO,KAAK;AACzB,SAAO,SAAS,MAAM,UAAU;AAClC;AAHgB;","names":[]}