@fastnear/utils 0.6.2 → 0.7.0

package/dist/umd/browser.global.js

@@ -1,5 +1,6 @@
-/* ⋈ 🏃🏻💨 FastNEAR Utils - IIFE/UMD (@fastnear/utils version 0.6.1) */
-/* https://www.npmjs.com/package/@fastnear/utils/v/0.6.1 */
+/* ⋈ 🏃🏻💨 FastNEAR Utils - IIFE/UMD (@fastnear/utils version 0.6.3) */
+/* https://www.npmjs.com/package/@fastnear/utils/v/0.6.3 */
+"use strict";
 var NearUtils = (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
@@ -39,30 +40,40 @@ var NearUtils = (() => {
   // src/index.ts
   var src_exports2 = {};
   __export(src_exports2, {
+    LsPrefix: () => LsPrefix,
     SCHEMA: () => SCHEMA,
+    base64ToBytes: () => base64ToBytes,
+    bytesToBase64: () => bytesToBase64,
     canSignWithLAK: () => canSignWithLAK,
     convertUnit: () => convertUnit,
+    createDefaultStorage: () => createDefaultStorage,
     deepCopy: () => deepCopy,
+    exp: () => exp,
     fromBase58: () => base58_to_binary_default,
     fromBase64: () => fromBase64,
+    fromHex: () => fromHex,
     keyFromString: () => keyFromString,
     keyToString: () => keyToString,
     lsGet: () => lsGet,
     lsSet: () => lsSet,
     mapAction: () => mapAction,
     mapTransaction: () => mapTransaction,
+    memoryStore: () => memoryStore,
     parseJsonFromBytes: () => parseJsonFromBytes,
     privateKeyFromRandom: () => privateKeyFromRandom,
     publicKeyFromPrivate: () => publicKeyFromPrivate,
-    reExportBorshSchema: () => src_exports,
     serializeSignedTransaction: () => serializeSignedTransaction,
     serializeTransaction: () => serializeTransaction,
     sha256: () => sha256,
     signBytes: () => signBytes,
     signHash: () => signHash,
+    storage: () => storage,
     toBase58: () => binary_to_base58_default,
     toBase64: () => toBase64,
-    tryParseJson: () => tryParseJson
+    toHex: () => toHex,
+    tryParseJson: () => tryParseJson,
+    txToJson: () => txToJson,
+    txToJsonStringified: () => txToJsonStringified
   });
 
   // ../../node_modules/@noble/curves/node_modules/@noble/hashes/esm/_assert.js
@@ -2595,6 +2606,7 @@ var NearUtils = (() => {
     }
     return _btoa(strs.join(""));
   };
+  var fromUint8Array = /* @__PURE__ */ __name((u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a), "fromUint8Array");
   var cb_utob = /* @__PURE__ */ __name((c) => {
     if (c.length < 2) {
       var cc = c.charCodeAt(0);
@@ -2635,30 +2647,83 @@ var NearUtils = (() => {
   }, "atobPolyfill");
   var _atob = typeof atob === "function" ? (asc) => atob(_tidyB64(asc)) : _hasBuffer ? (asc) => Buffer.from(asc, "base64").toString("binary") : atobPolyfill;
   var _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a).split("").map((c) => c.charCodeAt(0)));
+  var toUint8Array = /* @__PURE__ */ __name((a) => _toUint8Array(_unURI(a)), "toUint8Array");
   var _decode = _hasBuffer ? (a) => Buffer.from(a, "base64").toString("utf8") : _TD ? (a) => _TD.decode(_toUint8Array(a)) : (a) => btou(_atob(a));
   var _unURI = /* @__PURE__ */ __name((a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/")), "_unURI");
   var decode = /* @__PURE__ */ __name((src) => _decode(_unURI(src)), "decode");
 
-  // src/misc.ts
+  // src/storage.ts
   var LsPrefix = "__fastnear_";
-  function toBase64(data) {
-    if (typeof data === "string") {
-      return encode(data);
-    } else {
-      const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-      const str = String.fromCharCode(...bytes);
-      return encode(str);
+  var 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");
+  var memoryStore = /* @__PURE__ */ new Map();
+  var storageBackend = createDefaultStorage();
+  var 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")
+  };
+
+  // src/misc.ts
+  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 toUint8Array(b64Val);
+  }
+  __name(base64ToBytes, "base64ToBytes");
+  function bytesToBase64(bytesArr) {
+    return fromUint8Array(bytesArr);
+  }
+  __name(bytesToBase64, "bytesToBase64");
+  function toBase64(strVal) {
+    try {
+      return encode(strVal);
+    } catch (e) {
+      console.error("Issue base64 encoding", e);
+      return null;
     }
   }
   __name(toBase64, "toBase64");
-  function fromBase64(str) {
-    const binaryString = decode(str);
-    const len = binaryString.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
+  function fromBase64(strVal) {
+    try {
+      return decode(strVal);
+    } catch (e) {
+      console.error("Issue base64 decoding", e);
+      return null;
     }
-    return bytes;
   }
   __name(fromBase64, "fromBase64");
   function convertUnit(s, ...args) {
@@ -2691,20 +2756,15 @@ var NearUtils = (() => {
         }
       }
     }
-    return big_default(s).toFixed(0);
+    return big_default(`${s}`).toFixed(0);
   }
   __name(convertUnit, "convertUnit");
   function lsSet(key, value) {
-    if (value === null || value === void 0) {
-      localStorage.removeItem(LsPrefix + key);
-    } else {
-      localStorage.setItem(LsPrefix + key, JSON.stringify(value));
-    }
+    storage.set(key, value);
   }
   __name(lsSet, "lsSet");
   function lsGet(key) {
-    const value = localStorage.getItem(LsPrefix + key);
-    return tryParseJson(value, null);
+    return storage.get(key);
   }
   __name(lsGet, "lsGet");
   function deepCopy(obj) {
@@ -2754,8 +2814,8 @@ var NearUtils = (() => {
   ), "keyFromString");
   var keyToString = /* @__PURE__ */ __name((key) => `ed25519:${binary_to_base58_default(key)}`, "keyToString");
   function publicKeyFromPrivate(privateKey) {
-    privateKey = keyFromString(privateKey).slice(0, 32);
-    const publicKey = ed25519.getPublicKey(privateKey);
+    const secret = keyFromString(privateKey).slice(0, 32);
+    const publicKey = ed25519.getPublicKey(secret);
     return keyToString(publicKey);
   }
   __name(publicKeyFromPrivate, "publicKeyFromPrivate");
@@ -2764,15 +2824,18 @@ var NearUtils = (() => {
     return keyToString(privateKey);
   }
   __name(privateKeyFromRandom, "privateKeyFromRandom");
-  function signHash(hash, privateKey) {
-    privateKey = keyFromString(privateKey).slice(0, 32);
-    const signature = ed25519.sign(base58_to_binary_default(hash), privateKey);
-    return binary_to_base58_default(signature);
+  function signHash(hashBytes, privateKey, opts) {
+    const secret = keyFromString(privateKey).slice(0, 32);
+    const signature = ed25519.sign(hashBytes, secret);
+    if (opts?.returnBase58) {
+      return binary_to_base58_default(signature);
+    }
+    return signature;
   }
   __name(signHash, "signHash");
   function signBytes(bytes, privateKey) {
     const hash = sha256(bytes);
-    return signHash(binary_to_base58_default(hash), privateKey);
+    return signHash(hash, privateKey);
   }
   __name(signBytes, "signBytes");
 
@@ -3295,176 +3358,194 @@ var NearUtils = (() => {
     return serializer.encode(value, schema);
   }
   __name(serialize, "serialize");
+  function deserialize(schema, buffer, validate) {
+    if (validate === void 0) {
+      validate = true;
+    }
+    if (validate)
+      validate_schema(schema);
+    var deserializer = new BorshDeserializer(buffer);
+    return deserializer.decode(schema);
+  }
+  __name(deserialize, "deserialize");
 
   // ../borsh-schema/src/index.ts
   var src_exports = {};
   __export(src_exports, {
-    getBorshSchema: () => getBorshSchema
+    getBorshSchema: () => getBorshSchema,
+    nearChainSchema: () => nearChainSchema
   });
-  var getBorshSchema = (() => {
-    class BorshSchema {
-      static {
-        __name(this, "BorshSchema");
-      }
-      Ed25519Signature = {
-        struct: {
-          data: { array: { type: "u8", len: 64 } }
-        }
-      };
-      Secp256k1Signature = {
-        struct: {
-          data: { array: { type: "u8", len: 65 } }
-        }
-      };
-      Signature = {
-        enum: [
-          { struct: { ed25519Signature: this.Ed25519Signature } },
-          { struct: { secp256k1Signature: this.Secp256k1Signature } }
-        ]
-      };
-      Ed25519Data = {
-        struct: {
-          data: { array: { type: "u8", len: 32 } }
-        }
-      };
-      Secp256k1Data = {
-        struct: {
-          data: { array: { type: "u8", len: 64 } }
-        }
-      };
-      PublicKey = {
-        enum: [
-          { struct: { ed25519Key: this.Ed25519Data } },
-          { struct: { secp256k1Key: this.Secp256k1Data } }
-        ]
-      };
-      FunctionCallPermission = {
-        struct: {
-          allowance: { option: "u128" },
-          receiverId: "string",
-          methodNames: { array: { type: "string" } }
-        }
-      };
-      FullAccessPermission = {
-        struct: {}
-      };
-      AccessKeyPermission = {
-        enum: [
-          { struct: { functionCall: this.FunctionCallPermission } },
-          { struct: { fullAccess: this.FullAccessPermission } }
-        ]
-      };
-      AccessKey = {
-        struct: {
-          nonce: "u64",
-          permission: this.AccessKeyPermission
-        }
-      };
-      CreateAccount = {
-        struct: {}
-      };
-      DeployContract = {
-        struct: {
-          code: { array: { type: "u8" } }
-        }
-      };
-      FunctionCall = {
-        struct: {
-          methodName: "string",
-          args: { array: { type: "u8" } },
-          gas: "u64",
-          deposit: "u128"
-        }
-      };
-      Transfer = {
-        struct: {
-          deposit: "u128"
-        }
-      };
-      Stake = {
-        struct: {
-          stake: "u128",
-          publicKey: this.PublicKey
-        }
-      };
-      AddKey = {
-        struct: {
-          publicKey: this.PublicKey,
-          accessKey: this.AccessKey
-        }
-      };
-      DeleteKey = {
-        struct: {
-          publicKey: this.PublicKey
-        }
-      };
-      DeleteAccount = {
-        struct: {
-          beneficiaryId: "string"
-        }
-      };
-      ClassicAction = {
-        enum: [
-          { struct: { createAccount: this.CreateAccount } },
-          { struct: { deployContract: this.DeployContract } },
-          { struct: { functionCall: this.FunctionCall } },
-          { struct: { transfer: this.Transfer } },
-          { struct: { stake: this.Stake } },
-          { struct: { addKey: this.AddKey } },
-          { struct: { deleteKey: this.DeleteKey } },
-          { struct: { deleteAccount: this.DeleteAccount } }
-        ]
-      };
-      DelegateAction = {
-        struct: {
-          senderId: "string",
-          receiverId: "string",
-          actions: { array: { type: this.ClassicAction } },
-          nonce: "u64",
-          maxBlockHeight: "u64",
-          publicKey: this.PublicKey
-        }
-      };
-      SignedDelegate = {
-        struct: {
-          delegateAction: this.DelegateAction,
-          signature: this.Signature
-        }
-      };
-      Action = {
-        enum: [
-          { struct: { createAccount: this.CreateAccount } },
-          { struct: { deployContract: this.DeployContract } },
-          { struct: { functionCall: this.FunctionCall } },
-          { struct: { transfer: this.Transfer } },
-          { struct: { stake: this.Stake } },
-          { struct: { addKey: this.AddKey } },
-          { struct: { deleteKey: this.DeleteKey } },
-          { struct: { deleteAccount: this.DeleteAccount } },
-          { struct: { signedDelegate: this.SignedDelegate } }
-        ]
-      };
-      Transaction = {
-        struct: {
-          signerId: "string",
-          publicKey: this.PublicKey,
-          nonce: "u64",
-          receiverId: "string",
-          blockHash: { array: { type: "u8", len: 32 } },
-          actions: { array: { type: this.Action } }
-        }
-      };
-      SignedTransaction = {
-        struct: {
-          transaction: this.Transaction,
-          signature: this.Signature
-        }
-      };
+  var nearChainSchema = new class BorshSchema {
+    static {
+      __name(this, "BorshSchema");
     }
-    return new BorshSchema();
-  })();
+    Ed25519Signature = {
+      struct: {
+        data: { array: { type: "u8", len: 64 } }
+      }
+    };
+    Secp256k1Signature = {
+      struct: {
+        data: { array: { type: "u8", len: 65 } }
+      }
+    };
+    Signature = {
+      enum: [
+        { struct: { ed25519Signature: this.Ed25519Signature } },
+        { struct: { secp256k1Signature: this.Secp256k1Signature } }
+      ]
+    };
+    Ed25519Data = {
+      struct: {
+        data: { array: { type: "u8", len: 32 } }
+      }
+    };
+    Secp256k1Data = {
+      struct: {
+        data: { array: { type: "u8", len: 64 } }
+      }
+    };
+    PublicKey = {
+      enum: [
+        { struct: { ed25519Key: this.Ed25519Data } },
+        { struct: { secp256k1Key: this.Secp256k1Data } }
+      ]
+    };
+    FunctionCallPermission = {
+      struct: {
+        allowance: { option: "u128" },
+        receiverId: "string",
+        methodNames: { array: { type: "string" } }
+      }
+    };
+    FullAccessPermission = {
+      struct: {}
+    };
+    AccessKeyPermission = {
+      enum: [
+        { struct: { functionCall: this.FunctionCallPermission } },
+        { struct: { fullAccess: this.FullAccessPermission } }
+      ]
+    };
+    AccessKey = {
+      struct: {
+        nonce: "u64",
+        permission: this.AccessKeyPermission
+      }
+    };
+    CreateAccount = {
+      struct: {}
+    };
+    DeployContract = {
+      struct: {
+        code: { array: { type: "u8" } }
+      }
+    };
+    FunctionCall = {
+      struct: {
+        methodName: "string",
+        args: { array: { type: "u8" } },
+        gas: "u64",
+        deposit: "u128"
+      }
+    };
+    Transfer = {
+      struct: {
+        deposit: "u128"
+      }
+    };
+    Stake = {
+      struct: {
+        stake: "u128",
+        publicKey: this.PublicKey
+      }
+    };
+    AddKey = {
+      struct: {
+        publicKey: this.PublicKey,
+        accessKey: this.AccessKey
+      }
+    };
+    DeleteKey = {
+      struct: {
+        publicKey: this.PublicKey
+      }
+    };
+    DeleteAccount = {
+      struct: {
+        beneficiaryId: "string"
+      }
+    };
+    ClassicAction = {
+      enum: [
+        { struct: { createAccount: this.CreateAccount } },
+        { struct: { deployContract: this.DeployContract } },
+        { struct: { functionCall: this.FunctionCall } },
+        { struct: { transfer: this.Transfer } },
+        { struct: { stake: this.Stake } },
+        { struct: { addKey: this.AddKey } },
+        { struct: { deleteKey: this.DeleteKey } },
+        { struct: { deleteAccount: this.DeleteAccount } }
+      ]
+    };
+    DelegateAction = {
+      struct: {
+        senderId: "string",
+        receiverId: "string",
+        actions: { array: { type: this.ClassicAction } },
+        nonce: "u64",
+        maxBlockHeight: "u64",
+        publicKey: this.PublicKey
+      }
+    };
+    SignedDelegate = {
+      struct: {
+        delegateAction: this.DelegateAction,
+        signature: this.Signature
+      }
+    };
+    Action = {
+      enum: [
+        { struct: { createAccount: this.CreateAccount } },
+        { struct: { deployContract: this.DeployContract } },
+        { struct: { functionCall: this.FunctionCall } },
+        { struct: { transfer: this.Transfer } },
+        { struct: { stake: this.Stake } },
+        { struct: { addKey: this.AddKey } },
+        { struct: { deleteKey: this.DeleteKey } },
+        { struct: { deleteAccount: this.DeleteAccount } },
+        { struct: { signedDelegate: this.SignedDelegate } }
+      ]
+    };
+    Transaction = {
+      struct: {
+        signerId: "string",
+        publicKey: this.PublicKey,
+        nonce: "u64",
+        receiverId: "string",
+        blockHash: { array: { type: "u8", len: 32 } },
+        actions: { array: { type: this.Action } }
+      }
+    };
+    SignedTransaction = {
+      struct: {
+        transaction: this.Transaction,
+        signature: this.Signature
+      }
+    };
+  }();
+  var getBorshSchema = /* @__PURE__ */ __name(() => nearChainSchema, "getBorshSchema");
 
   // src/transaction.ts
+  var txToJson = /* @__PURE__ */ __name((tx) => {
+    return JSON.parse(JSON.stringify(
+      tx,
+      (key, value) => typeof value === "bigint" ? value.toString() : value
+    ));
+  }, "txToJson");
+  var txToJsonStringified = /* @__PURE__ */ __name((tx) => {
+    return JSON.stringify(txToJson(tx));
+  }, "txToJsonStringified");
   function mapTransaction(jsonTransaction) {
     return {
       signerId: jsonTransaction.signerId,
@@ -3481,20 +3562,29 @@ var NearUtils = (() => {
   }
   __name(mapTransaction, "mapTransaction");
   function serializeTransaction(jsonTransaction) {
+    console.log("fastnear: serializing transaction");
     const transaction = mapTransaction(jsonTransaction);
+    console.log("fastnear: mapped transaction for borsh:", transaction);
     return serialize(SCHEMA.Transaction, transaction);
   }
   __name(serializeTransaction, "serializeTransaction");
   function serializeSignedTransaction(jsonTransaction, signature) {
-    const signedTransaction = {
-      transaction: mapTransaction(jsonTransaction),
+    console.log("fastnear: Serializing Signed Transaction", jsonTransaction);
+    console.log("fastnear: signature", signature);
+    console.log("fastnear: signature length", base58_to_binary_default(signature).length);
+    const mappedSignedTx = mapTransaction(jsonTransaction);
+    console.log("fastnear: mapped (for borsh schema) signed transaction", mappedSignedTx);
+    const plainSignedTransaction = {
+      transaction: mappedSignedTx,
       signature: {
         ed25519Signature: {
           data: base58_to_binary_default(signature)
         }
       }
     };
-    return serialize(SCHEMA.SignedTransaction, signedTransaction);
+    const borshSignedTx = serialize(SCHEMA.SignedTransaction, plainSignedTransaction, true);
+    console.log("fastnear: borsh-serialized signed transaction:", borshSignedTx);
+    return borshSignedTx;
   }
   __name(serializeSignedTransaction, "serializeSignedTransaction");
   function mapAction(action) {
@@ -3512,10 +3602,12 @@ var NearUtils = (() => {
         };
       }
       case "FunctionCall": {
+        const argsAsString = JSON.stringify(action.args);
+        const argsEncoded = new TextEncoder().encode(argsAsString);
         return {
           functionCall: {
             methodName: action.methodName,
-            args: action.argsBase64 ? fromBase64(action.argsBase64) : new TextEncoder().encode(JSON.stringify(action.args)),
+            args: argsEncoded,
             gas: BigInt(action.gas),
             deposit: BigInt(action.deposit)
           }
@@ -3595,7 +3687,16 @@ var NearUtils = (() => {
     }
   }
   __name(mapAction, "mapAction");
-  var SCHEMA = getBorshSchema;
+  var SCHEMA = getBorshSchema();
+
+  // src/index.ts
+  var exp = {
+    borsh: {
+      serialize,
+      deserialize
+    },
+    borshSchema: src_exports
+  };
   return __toCommonJS(src_exports2);
 })();
 /*! Bundled license information:
@@ -3622,15 +3723,10 @@ var NearUtils = (() => {
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-if (typeof globalThis.NearUtils === 'undefined') {
-  console.warn('No globalThis.NearUtils');
-} else {
-  Object.defineProperty(globalThis, 'NearUtils', {
-    value: globalThis.NearUtils,
-    writable: false,
-    enumerable: true,
-    configurable: false,
-  });
-}
+Object.defineProperty(globalThis, 'NearUtils', {
+  value: NearUtils,
+  enumerable: true,
+  configurable: false,
+});
 
 //# sourceMappingURL=browser.global.js.map