@fastnear/api 0.6.2 → 0.7.0

package/dist/umd/browser.global.js

@@ -1,5 +1,6 @@
-/* ⋈ 🏃🏻💨 FastNEAR API - IIFE/UMD (@fastnear/api version 0.6.1) */
-/* https://www.npmjs.com/package/@fastnear/api/v/0.6.1 */
+/* ⋈ 🏃🏻💨 FastNEAR API - IIFE/UMD (@fastnear/api version 0.6.3) */
+/* https://www.npmjs.com/package/@fastnear/api/v/0.6.3 */
+"use strict";
 var near = (() => {
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -23,24 +24,46 @@ var near = (() => {
   // src/index.ts
   var src_exports3 = {};
   __export(src_exports3, {
+    DEFAULT_NETWORK_ID: () => DEFAULT_NETWORK_ID,
     MaxBlockDelayMs: () => MaxBlockDelayMs,
-    accessKey: () => accessKey,
-    account: () => account,
+    NETWORKS: () => NETWORKS,
+    WIDGET_URL: () => WIDGET_URL,
+    _adapter: () => _adapter,
+    _config: () => _config,
+    _eventListeners: () => _eventListeners,
+    _state: () => _state,
+    _txHistory: () => _txHistory,
+    _unbroadcastedEvents: () => _unbroadcastedEvents,
     accountId: () => accountId,
     actions: () => actions,
     afterTxSent: () => afterTxSent,
     authStatus: () => authStatus,
-    block: () => block,
     config: () => config,
+    exp: () => exp2,
+    generateTxId: () => generateTxId,
+    getConfig: () => getConfig,
+    getTxHistory: () => getTxHistory,
+    getWalletAdapterState: () => getWalletAdapterState,
     localTxHistory: () => localTxHistory,
+    notifyAccountListeners: () => notifyAccountListeners,
+    notifyTxListeners: () => notifyTxListeners,
+    onAccount: () => onAccount,
+    onAdapterStateUpdate: () => onAdapterStateUpdate,
+    onTx: () => onTx,
     publicKey: () => publicKey,
+    queryAccessKey: () => queryAccessKey,
+    queryAccount: () => queryAccount,
+    queryBlock: () => queryBlock,
     queryRpc: () => queryRpc,
-    reExports: () => reExports,
+    queryTx: () => queryTx,
     requestSignIn: () => requestSignIn,
+    resetTxHistory: () => resetTxHistory,
     sendTx: () => sendTx,
     sendTxToRpc: () => sendTxToRpc,
+    setConfig: () => setConfig,
     signOut: () => signOut,
-    tx: () => tx,
+    updateState: () => updateState,
+    updateTxHistory: () => updateTxHistory,
     utils: () => utils,
     view: () => view,
     withBlockId: () => withBlockId
@@ -49,30 +72,40 @@ var near = (() => {
   // ../utils/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
@@ -2604,6 +2637,7 @@ var near = (() => {
     }
     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);
@@ -2644,30 +2678,83 @@ var near = (() => {
   }, "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");
 
-  // ../utils/src/misc.ts
+  // ../utils/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")
+  };
+
+  // ../utils/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) {
@@ -2700,20 +2787,15 @@ var near = (() => {
         }
       }
     }
-    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) {
@@ -2763,8 +2845,8 @@ var near = (() => {
   ), "keyFromString");
   var keyToString = /* @__PURE__ */ __name((key) => `ed25519:${binary_to_base58_default(key)}`, "keyToString");
   function publicKeyFromPrivate(privateKey) {
-    privateKey = keyFromString(privateKey).slice(0, 32);
-    const publicKey2 = ed25519.getPublicKey(privateKey);
+    const secret = keyFromString(privateKey).slice(0, 32);
+    const publicKey2 = ed25519.getPublicKey(secret);
     return keyToString(publicKey2);
   }
   __name(publicKeyFromPrivate, "publicKeyFromPrivate");
@@ -2773,15 +2855,18 @@ var near = (() => {
     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");
 
@@ -3304,176 +3389,194 @@ var near = (() => {
     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");
 
   // ../utils/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,
@@ -3490,20 +3593,29 @@ var near = (() => {
   }
   __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) {
@@ -3521,10 +3633,12 @@ var near = (() => {
         };
       }
       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)
           }
@@ -3604,7 +3718,16 @@ var near = (() => {
     }
   }
   __name(mapAction, "mapAction");
-  var SCHEMA = getBorshSchema;
+  var SCHEMA = getBorshSchema();
+
+  // ../utils/src/index.ts
+  var exp = {
+    borsh: {
+      serialize,
+      deserialize
+    },
+    borshSchema: src_exports
+  };
 
   // ../wallet-adapter/src/index.ts
   var WalletAdapter = class _WalletAdapter {
@@ -3654,7 +3777,6 @@ var near = (() => {
         this.#iframe.remove();
       }
       const url = new URL(path, this.#widgetUrl);
-      console.log("aloha wa url", url);
       const iframe = document.createElement("iframe");
       iframe.src = url.toString();
       iframe.allow = "usb";
@@ -3743,10 +3865,12 @@ var near = (() => {
     /**
      * Sign in with a NEAR wallet
      * @param {SignInConfig} config
-     * @returns {Promise<SignInResult>}
+     * @returns {Promise<any>}
+     *
+     * Should be returning SignInResult
      */
     async signIn(config2) {
-      return this.#sendMessage("/public/login.html", "signIn", config2);
+      return this.#sendMessage("/login.html", "signIn", config2);
     }
     /**
      * Send a transaction using connected wallet
@@ -3754,7 +3878,7 @@ var near = (() => {
      * @returns {Promise<TransactionResult>}
      */
     async sendTransactions(config2) {
-      return this.#sendMessage("/public/send.html", "sendTransactions", config2);
+      return this.#sendMessage("/send.html", "sendTransactions", config2);
     }
     /**
      * Clean up adapter resources
@@ -3783,6 +3907,23 @@ var near = (() => {
     ...NETWORKS[DEFAULT_NETWORK_ID]
   };
   var _state = lsGet("state") || {};
+  var onAdapterStateUpdate = /* @__PURE__ */ __name((state) => {
+    console.log("Adapter state update:", state);
+    const { accountId: accountId2, lastWalletId, privateKey } = state;
+    updateState({
+      accountId: accountId2 || void 0,
+      lastWalletId: lastWalletId || void 0,
+      ...privateKey ? { privateKey } : {}
+    });
+  }, "onAdapterStateUpdate");
+  var getWalletAdapterState = /* @__PURE__ */ __name(() => {
+    return {
+      publicKey: _state.publicKey,
+      accountId: _state.accountId,
+      lastWalletId: _state.lastWalletId,
+      networkId: DEFAULT_NETWORK_ID
+    };
+  }, "getWalletAdapterState");
   var _adapter = new WalletAdapter({
     onStateUpdate: onAdapterStateUpdate,
     lastState: getWalletAdapterState(),
@@ -3804,16 +3945,7 @@ var near = (() => {
     account: [],
     tx: []
   };
-  function getWalletAdapterState() {
-    return {
-      publicKey: _state.publicKey,
-      accountId: _state.accountId,
-      lastWalletId: _state.lastWalletId,
-      networkId: DEFAULT_NETWORK_ID
-    };
-  }
-  __name(getWalletAdapterState, "getWalletAdapterState");
-  function updateState(newState) {
+  var updateState = /* @__PURE__ */ __name((newState) => {
     const oldState = _state;
     _state = { ..._state, ...newState };
     lsSet("state", {
@@ -3832,9 +3964,8 @@ var near = (() => {
     if (newState.hasOwnProperty("lastWalletId") && newState.lastWalletId !== oldState.lastWalletId || newState.hasOwnProperty("accountId") && newState.accountId !== oldState.accountId || newState.hasOwnProperty("privateKey") && newState.privateKey !== oldState.privateKey) {
       _adapter.setState(getWalletAdapterState());
     }
-  }
-  __name(updateState, "updateState");
-  function updateTxHistory(txStatus) {
+  }, "updateState");
+  var updateTxHistory = /* @__PURE__ */ __name((txStatus) => {
     const txId = txStatus.txId;
     _txHistory[txId] = {
       ..._txHistory[txId] || {},
@@ -3843,19 +3974,8 @@ var near = (() => {
     };
     lsSet("txHistory", _txHistory);
     notifyTxListeners(_txHistory[txId]);
-  }
-  __name(updateTxHistory, "updateTxHistory");
-  function onAdapterStateUpdate(state) {
-    console.log("Adapter state update:", state);
-    const { accountId: accountId2, lastWalletId, privateKey } = state;
-    updateState({
-      accountId: accountId2 || void 0,
-      lastWalletId: lastWalletId || void 0,
-      ...privateKey ? { privateKey } : {}
-    });
-  }
-  __name(onAdapterStateUpdate, "onAdapterStateUpdate");
-  function notifyAccountListeners(accountId2) {
+  }, "updateTxHistory");
+  var notifyAccountListeners = /* @__PURE__ */ __name((accountId2) => {
     if (_eventListeners.account.size === 0) {
       _unbroadcastedEvents.account.push(accountId2);
       return;
@@ -3867,50 +3987,67 @@ var near = (() => {
         console.error(e);
       }
     });
-  }
-  __name(notifyAccountListeners, "notifyAccountListeners");
-  function notifyTxListeners(tx2) {
+  }, "notifyAccountListeners");
+  var notifyTxListeners = /* @__PURE__ */ __name((tx) => {
     if (_eventListeners.tx.size === 0) {
-      _unbroadcastedEvents.tx.push(tx2);
+      _unbroadcastedEvents.tx.push(tx);
       return;
     }
     _eventListeners.tx.forEach((callback) => {
       try {
-        callback(tx2);
+        callback(tx);
       } catch (e) {
         console.error(e);
       }
     });
-  }
-  __name(notifyTxListeners, "notifyTxListeners");
-  function getConfig() {
+  }, "notifyTxListeners");
+  var onAccount = /* @__PURE__ */ __name((callback) => {
+    _eventListeners.account.add(callback);
+    if (_unbroadcastedEvents.account.length > 0) {
+      const events = _unbroadcastedEvents.account;
+      _unbroadcastedEvents.account = [];
+      events.forEach(notifyAccountListeners);
+    }
+  }, "onAccount");
+  var onTx = /* @__PURE__ */ __name((callback) => {
+    _eventListeners.tx.add(callback);
+    if (_unbroadcastedEvents.tx.length > 0) {
+      const events = _unbroadcastedEvents.tx;
+      _unbroadcastedEvents.tx = [];
+      events.forEach(notifyTxListeners);
+    }
+  }, "onTx");
+  var getConfig = /* @__PURE__ */ __name(() => {
     return _config;
-  }
-  __name(getConfig, "getConfig");
-  function getTxHistory() {
+  }, "getConfig");
+  var getTxHistory = /* @__PURE__ */ __name(() => {
     return _txHistory;
-  }
-  __name(getTxHistory, "getTxHistory");
-  function setConfig(newConf) {
-    _config = newConf;
-    lsSet("config", { ...NETWORKS[_config.networkId] });
-  }
-  __name(setConfig, "setConfig");
-  function resetTxHistory() {
+  }, "getTxHistory");
+  var setConfig = /* @__PURE__ */ __name((newConf) => {
+    _config = { ...NETWORKS[newConf.networkId], ...newConf };
+    lsSet("config", _config);
+  }, "setConfig");
+  var resetTxHistory = /* @__PURE__ */ __name(() => {
     _txHistory = {};
     lsSet("txHistory", _txHistory);
-  }
-  __name(resetTxHistory, "resetTxHistory");
+  }, "resetTxHistory");
 
   // src/near.ts
   big_default.DP = 27;
   var MaxBlockDelayMs = 1e3 * 60 * 60 * 6;
   function withBlockId(params, blockId) {
-    return blockId === "final" || blockId === "optimistic" ? { ...params, finality: blockId } : blockId ? { ...params, block_id: blockId } : { ...params, finality: "optimistic" };
+    if (blockId === "final" || blockId === "optimistic") {
+      return { ...params, finality: blockId };
+    }
+    return blockId ? { ...params, block_id: blockId } : { ...params, finality: "optimistic" };
   }
   __name(withBlockId, "withBlockId");
   async function queryRpc(method, params) {
-    const response = await fetch(getConfig().nodeUrl, {
+    const config2 = getConfig();
+    if (!config2?.nodeUrl) {
+      throw new Error("fastnear: getConfig() returned invalid config: missing nodeUrl.");
+    }
+    const response = await fetch(config2.nodeUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -3930,8 +4067,8 @@ var near = (() => {
   function afterTxSent(txId) {
     const txHistory = getTxHistory();
     queryRpc("tx", {
-      tx_hash: txHistory[txId].txHash,
-      sender_account_id: txHistory[txId].tx.signerId,
+      tx_hash: txHistory[txId]?.txHash,
+      sender_account_id: txHistory[txId]?.tx?.signerId,
       wait_until: "EXECUTED_OPTIMISTIC"
     }).then((result) => {
       const successValue = result?.status?.SuccessValue;
@@ -3946,57 +4083,51 @@ var near = (() => {
       updateTxHistory({
         txId,
         status: "ErrorAfterIncluded",
-        error: tryParseJson(error.message),
+        error: tryParseJson(error.message) ?? error.message,
         finalState: true
       });
     });
   }
   __name(afterTxSent, "afterTxSent");
-  function sendTxToRpc(signedTxBase64, waitUntil, txId) {
-    queryRpc("send_tx", {
-      signed_tx_base64: signedTxBase64,
-      wait_until: waitUntil ?? "INCLUDED"
-    }).then((result) => {
-      console.log("Transaction included:", result);
-      updateTxHistory({
-        txId,
-        status: "Included",
-        finalState: false
+  async function sendTxToRpc(signedTxBase64, waitUntil, txId) {
+    waitUntil = waitUntil || "INCLUDED";
+    try {
+      const sendTxRes = await queryRpc("send_tx", {
+        signed_tx_base64: signedTxBase64,
+        wait_until: waitUntil
       });
+      updateTxHistory({ txId, status: "Included", finalState: false });
       afterTxSent(txId);
-    }).catch((error) => {
+      return sendTxRes;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
       updateTxHistory({
         txId,
         status: "Error",
-        error: tryParseJson(error.message),
+        error: tryParseJson(errorMessage) ?? errorMessage,
         finalState: false
       });
-    });
+      throw new Error(errorMessage);
+    }
   }
   __name(sendTxToRpc, "sendTxToRpc");
-  var accountId = /* @__PURE__ */ __name(() => {
-    return _state.accountId;
-  }, "accountId");
-  var publicKey = /* @__PURE__ */ __name(() => {
-    return _state.publicKey;
-  }, "publicKey");
+  function generateTxId() {
+    const randomPart = crypto.getRandomValues(new Uint32Array(2)).join("");
+    return `tx-${Date.now()}-${parseInt(randomPart, 10).toString(36)}`;
+  }
+  __name(generateTxId, "generateTxId");
+  var accountId = /* @__PURE__ */ __name(() => _state.accountId, "accountId");
+  var publicKey = /* @__PURE__ */ __name(() => _state.publicKey, "publicKey");
   var config = /* @__PURE__ */ __name((newConfig) => {
     const current = getConfig();
     if (newConfig) {
       if (newConfig.networkId && current.networkId !== newConfig.networkId) {
         setConfig(newConfig.networkId);
-        updateState({
-          accountId: null,
-          privateKey: null,
-          lastWalletId: null
-        });
+        updateState({ accountId: null, privateKey: null, lastWalletId: null });
         lsSet("block", null);
         resetTxHistory();
       }
-      setConfig({
-        ...getConfig(),
-        ...newConfig
-      });
+      setConfig({ ...getConfig(), ...newConfig });
     }
     return getConfig();
   }, "config");
@@ -4004,17 +4135,30 @@ var near = (() => {
     if (!_state.accountId) {
       return "SignedOut";
     }
-    const accessKey2 = _state.publicKey;
-    const contractId = _state.accessKeyContractId;
-    if (accessKey2 && contractId && _state.privateKey) {
-      return {
-        type: "SignedInWithLimitedAccessKey",
-        accessKey: accessKey2,
-        contractId
-      };
-    }
     return "SignedIn";
   }, "authStatus");
+  var requestSignIn = /* @__PURE__ */ __name(async ({ contractId }) => {
+    const privateKey = privateKeyFromRandom();
+    updateState({ accessKeyContractId: contractId, accountId: null, privateKey });
+    const pubKey = publicKeyFromPrivate(privateKey);
+    const result = await _adapter.signIn({
+      networkId: getConfig().networkId,
+      contractId,
+      publicKey: pubKey
+    });
+    if (result.error) {
+      throw new Error(`Wallet error: ${result.error}`);
+    }
+    if (result.url) {
+      if (typeof window !== "undefined") {
+        setTimeout(() => {
+          window.location.href = result.url;
+        }, 100);
+      }
+    } else if (result.accountId) {
+      updateState({ accountId: result.accountId });
+    }
+  }, "requestSignIn");
   var view = /* @__PURE__ */ __name(async ({
     contractId,
     methodName,
@@ -4037,25 +4181,19 @@ var near = (() => {
     );
     return parseJsonFromBytes(result.result);
   }, "view");
-  var account = /* @__PURE__ */ __name(async ({
+  var queryAccount = /* @__PURE__ */ __name(async ({
     accountId: accountId2,
     blockId
   }) => {
     return queryRpc(
       "query",
-      withBlockId(
-        {
-          request_type: "view_account",
-          account_id: accountId2
-        },
-        blockId
-      )
+      withBlockId({ request_type: "view_account", account_id: accountId2 }, blockId)
     );
-  }, "account");
-  var block = /* @__PURE__ */ __name(async ({ blockId }) => {
+  }, "queryAccount");
+  var queryBlock = /* @__PURE__ */ __name(async ({ blockId }) => {
     return queryRpc("block", withBlockId({}, blockId));
-  }, "block");
-  var accessKey = /* @__PURE__ */ __name(async ({
+  }, "queryBlock");
+  var queryAccessKey = /* @__PURE__ */ __name(async ({
     accountId: accountId2,
     publicKey: publicKey2,
     blockId
@@ -4063,78 +4201,59 @@ var near = (() => {
     return queryRpc(
       "query",
       withBlockId(
-        {
-          request_type: "view_access_key",
-          account_id: accountId2,
-          public_key: publicKey2
-        },
+        { request_type: "view_access_key", account_id: accountId2, public_key: publicKey2 },
         blockId
       )
     );
-  }, "accessKey");
-  var tx = /* @__PURE__ */ __name(async ({
-    txHash,
-    accountId: accountId2
-  }) => {
+  }, "queryAccessKey");
+  var queryTx = /* @__PURE__ */ __name(async ({ txHash, accountId: accountId2 }) => {
     return queryRpc("tx", [txHash, accountId2]);
-  }, "tx");
+  }, "queryTx");
   var localTxHistory = /* @__PURE__ */ __name(() => {
     return getTxHistory();
   }, "localTxHistory");
+  var signOut = /* @__PURE__ */ __name(() => {
+    updateState({ accountId: null, privateKey: null, contractId: null });
+    setConfig(NETWORKS[DEFAULT_NETWORK_ID]);
+  }, "signOut");
   var sendTx = /* @__PURE__ */ __name(async ({
     receiverId,
     actions: actions2,
     waitUntil
   }) => {
     const signerId = _state.accountId;
-    if (!signerId) {
-      throw new Error("Not signed in");
-    }
-    const publicKey2 = _state.publicKey;
-    const privateKey = _state.privateKey;
-    const txId = `tx-${Date.now()}-${Math.random()}`;
-    if (!privateKey || receiverId !== _state.accessKeyContractId || !canSignWithLAK(actions2)) {
-      const jsonTransaction2 = {
-        signerId,
-        receiverId,
-        actions: actions2
-      };
-      updateTxHistory({
-        status: "Pending",
-        txId,
-        tx: jsonTransaction2,
-        finalState: false
-      });
+    if (!signerId) throw new Error("Must sign in");
+    const publicKey2 = _state.publicKey ?? "";
+    const privKey = _state.privateKey;
+    const txId = generateTxId();
+    if (!privKey || receiverId !== _state.accessKeyContractId || !canSignWithLAK(actions2)) {
+      const jsonTx = { signerId, receiverId, actions: actions2 };
+      updateTxHistory({ status: "Pending", txId, tx: jsonTx, finalState: false });
       const url = new URL(typeof window !== "undefined" ? window.location.href : "");
       url.searchParams.set("txIds", txId);
-      _adapter.sendTransactions({
-        transactions: [jsonTransaction2],
-        callbackUrl: url.toString()
-      }).then((result) => {
-        console.log("Transaction result:", result);
+      try {
+        const result = await _adapter.sendTransactions({
+          transactions: [jsonTx],
+          callbackUrl: url.toString()
+        });
         if (result.url) {
-          console.log("Redirecting to wallet:", result.url);
           if (typeof window !== "undefined") {
             setTimeout(() => {
               window.location.href = result.url;
             }, 100);
           }
-        } else if (result.outcomes) {
-          result.outcomes.forEach((r) => {
-            updateTxHistory({
+        } else if (result.outcomes?.length) {
+          result.outcomes.forEach(
+            (r) => updateTxHistory({
               txId,
               status: "Executed",
               result: r,
               txHash: r.transaction.hash,
               finalState: true
-            });
-          });
+            })
+          );
         } else if (result.rejected) {
-          updateTxHistory({
-            txId,
-            status: "RejectedByUser",
-            finalState: true
-          });
+          updateTxHistory({ txId, status: "RejectedByUser", finalState: true });
         } else if (result.error) {
           updateTxHistory({
             txId,
@@ -4143,121 +4262,132 @@ var near = (() => {
             finalState: true
           });
         }
-      }).catch((error) => {
+        return result;
+      } catch (err) {
+        console.error("fastnear: error sending tx using adapter:", err);
         updateTxHistory({
           txId,
           status: "Error",
-          error: tryParseJson(error.message),
+          error: tryParseJson(err.message),
           finalState: true
         });
-      });
-      return txId;
+        return Promise.reject(err);
+      }
     }
     let nonce = lsGet("nonce");
-    let block2 = lsGet("block");
-    const toDoPromises = {};
-    if (nonce === null || nonce === void 0) {
-      toDoPromises.nonce = accessKey({
-        accountId: signerId,
-        publicKey: publicKey2
-      }).then((accessKey2) => {
-        if (accessKey2.error) {
-          throw new Error(`Access key error: ${accessKey2.error}`);
-        }
-        lsSet("nonce", accessKey2.nonce);
-        return accessKey2.nonce;
-      });
-    }
-    if (!block2 || !block2.header || parseFloat(block2.header.timestamp_nanosec) / 1e6 + MaxBlockDelayMs < Date.now()) {
-      toDoPromises.block = block2({ blockId: "final" }).then((b) => {
-        const newBlock = {
-          header: {
-            prev_hash: b.header.prev_hash,
-            timestamp_nanosec: b.header.timestamp_nanosec
-          }
-        };
-        lsSet("block", newBlock);
-        return newBlock;
-      });
-    }
-    if (Object.keys(toDoPromises).length > 0) {
-      const results = await Promise.all(Object.values(toDoPromises));
-      const keys = Object.keys(toDoPromises);
-      results.forEach((res, i) => {
-        if (keys[i] === "nonce") {
-          nonce = res;
-        } else if (keys[i] === "block") {
-          block2 = res;
+    if (nonce == null) {
+      const accessKey = await queryAccessKey({ accountId: signerId, publicKey: publicKey2 });
+      if (accessKey.error) {
+        throw new Error(`Access key error: ${accessKey.error} when attempting to get nonce for ${signerId} for public key ${publicKey2}`);
+      }
+      nonce = accessKey.nonce;
+      lsSet("nonce", nonce);
+    }
+    let lastKnownBlock = lsGet("block");
+    if (!lastKnownBlock || parseFloat(lastKnownBlock.header.timestamp_nanosec) / 1e6 + MaxBlockDelayMs < Date.now()) {
+      const latestBlock = await queryBlock({ blockId: "final" });
+      lastKnownBlock = {
+        header: {
+          prev_hash: latestBlock.header.prev_hash,
+          timestamp_nanosec: latestBlock.header.timestamp_nanosec
         }
-      });
+      };
+      lsSet("block", lastKnownBlock);
     }
-    const newNonce = (nonce ?? 0) + 1;
-    lsSet("nonce", newNonce);
-    const blockHash = block2.header.prev_hash;
-    const jsonTransaction = {
+    nonce += 1;
+    lsSet("nonce", nonce);
+    const blockHash = lastKnownBlock.header.prev_hash;
+    const plainTransactionObj = {
       signerId,
       publicKey: publicKey2,
-      nonce: newNonce,
+      nonce,
       receiverId,
       blockHash,
       actions: actions2
     };
-    console.log("Transaction:", jsonTransaction);
-    const transaction = serializeTransaction(jsonTransaction);
-    const txHash = binary_to_base58_default(sha256(transaction));
-    const signature = signHash(txHash, privateKey);
-    const signedTransaction = serializeSignedTransaction(jsonTransaction, signature);
-    const signedTxBase64 = toBase64(signedTransaction);
+    const txBytes = serializeTransaction(plainTransactionObj);
+    const txHashBytes = sha256(txBytes);
+    const txHash58 = binary_to_base58_default(txHashBytes);
+    const signatureBase58 = signHash(txHashBytes, privKey, { returnBase58: true });
+    const signedTransactionBytes = serializeSignedTransaction(plainTransactionObj, signatureBase58);
+    const signedTxBase64 = bytesToBase64(signedTransactionBytes);
     updateTxHistory({
       status: "Pending",
       txId,
-      tx: jsonTransaction,
-      signature,
+      tx: plainTransactionObj,
+      signature: signatureBase58,
       signedTxBase64,
-      txHash,
+      txHash: txHash58,
       finalState: false
     });
-    sendTxToRpc(signedTxBase64, waitUntil, txId);
-    return txId;
-  }, "sendTx");
-  var requestSignIn = /* @__PURE__ */ __name(async ({ contractId }) => {
-    const privateKey = privateKeyFromRandom();
-    updateState({
-      accessKeyContractId: contractId,
-      accountId: null,
-      privateKey
-    });
-    const publicKey2 = publicKeyFromPrivate(privateKey);
-    const result = await _adapter.signIn({
-      networkId: getConfig().networkId,
-      // (C) replaced _config.networkId
-      contractId,
-      publicKey: publicKey2
-    });
-    console.log("Sign in result:", result);
-    if (result.error) {
-      throw new Error(`Wallet error: ${result.error}`);
+    try {
+      return await sendTxToRpc(signedTxBase64, waitUntil, txId);
+    } catch (error) {
+      console.error("Error Sending Transaction:", error, plainTransactionObj, signedTxBase64);
     }
-    if (result.url) {
-      console.log("Redirecting to wallet:", result.url);
-      if (typeof window !== "undefined") {
-        setTimeout(() => {
-          window.location.href = result.url;
-        }, 100);
+  }, "sendTx");
+  var exp2 = {
+    utils: {},
+    // we will map this in a moment, giving keys, for IDE hints
+    borsh: exp.borsh,
+    borshSchema: exp.borshSchema.getBorshSchema()
+  };
+  for (const key in src_exports2) {
+    exp2.utils[key] = src_exports2[key];
+  }
+  var utils = exp2.utils;
+  try {
+    if (typeof window !== "undefined") {
+      const url = new URL(window.location.href);
+      const accId = url.searchParams.get("account_id");
+      const pubKey = url.searchParams.get("public_key");
+      const errCode = url.searchParams.get("errorCode");
+      const errMsg = url.searchParams.get("errorMessage");
+      const txHashes = url.searchParams.get("transactionHashes");
+      const txIds = url.searchParams.get("txIds");
+      if (errCode || errMsg) {
+        console.warn(new Error(`Wallet error: ${errCode} ${errMsg}`));
       }
-    } else if (result.accountId) {
-      updateState({
-        accountId: result.accountId
-      });
+      if (accId && pubKey) {
+        if (pubKey === _state.publicKey) {
+          updateState({ accountId: accId });
+        } else {
+          console.error(new Error("Public key mismatch from wallet redirect"), pubKey, _state.publicKey);
+        }
+      }
+      if (txHashes || txIds) {
+        const hashArr = txHashes ? txHashes.split(",") : [];
+        const idArr = txIds ? txIds.split(",") : [];
+        if (idArr.length > hashArr.length) {
+          idArr.forEach((id) => {
+            updateTxHistory({ txId: id, status: "RejectedByUser", finalState: true });
+          });
+        } else if (idArr.length === hashArr.length) {
+          idArr.forEach((id, i) => {
+            updateTxHistory({
+              txId: id,
+              status: "PendingGotTxHash",
+              txHash: hashArr[i],
+              finalState: false
+            });
+            afterTxSent(id);
+          });
+        } else {
+          console.error(new Error("Transaction hash mismatch from wallet redirect"), idArr, hashArr);
+        }
+      }
+      url.searchParams.delete("account_id");
+      url.searchParams.delete("public_key");
+      url.searchParams.delete("errorCode");
+      url.searchParams.delete("errorMessage");
+      url.searchParams.delete("all_keys");
+      url.searchParams.delete("transactionHashes");
+      url.searchParams.delete("txIds");
+      window.history.replaceState({}, "", url.toString());
     }
-  }, "requestSignIn");
-  var signOut = /* @__PURE__ */ __name(() => {
-    updateState({
-      accountId: null,
-      privateKey: null,
-      contractId: null
-    });
-  }, "signOut");
+  } catch (e) {
+    console.error("Error handling wallet redirect:", e);
+  }
   var actions = {
     functionCall: /* @__PURE__ */ __name(({
       methodName,
@@ -4318,82 +4448,6 @@ var near = (() => {
       codeBase64
     }), "deployContract")
   };
-  var reExports = {
-    utils: src_exports2,
-    borshSchema: src_exports
-  };
-  var utils = reExports.utils;
-  try {
-    if (typeof window !== "undefined") {
-      const url = new URL(window.location.href);
-      const accountId2 = url.searchParams.get("account_id");
-      const publicKey2 = url.searchParams.get("public_key");
-      const errorCode = url.searchParams.get("errorCode");
-      const errorMessage = url.searchParams.get("errorMessage");
-      const transactionHashes = url.searchParams.get("transactionHashes");
-      const txIds = url.searchParams.get("txIds");
-      if (errorCode || errorMessage) {
-        console.warn(new Error(`Wallet error: ${errorCode} ${errorMessage}`));
-      }
-      if (accountId2 && publicKey2) {
-        if (publicKey2 === _state.publicKey) {
-          updateState({
-            accountId: accountId2
-          });
-        } else {
-          console.error(
-            new Error("Public key mismatch from wallet redirect"),
-            publicKey2,
-            _state.publicKey
-          );
-        }
-      }
-      if (transactionHashes || txIds) {
-        const txHashes = transactionHashes ? transactionHashes.split(",") : [];
-        const txIdsArray = txIds ? txIds.split(",") : [];
-        if (txIdsArray.length > txHashes.length) {
-          txIdsArray.forEach((txId, i) => {
-            updateTxHistory({
-              txId,
-              status: "RejectedByUser",
-              finalState: true
-            });
-          });
-        } else if (txIdsArray.length === txHashes.length) {
-          txIdsArray.forEach((txId, i) => {
-            updateTxHistory({
-              txId,
-              status: "PendingGotTxHash",
-              txHash: txHashes[i],
-              finalState: false
-            });
-            afterTxSent(txId);
-          });
-        } else {
-          console.error(
-            new Error("Transaction hash mismatch from wallet redirect"),
-            txIdsArray,
-            txHashes
-          );
-        }
-      }
-      url.searchParams.delete("account_id");
-      url.searchParams.delete("public_key");
-      url.searchParams.delete("errorCode");
-      url.searchParams.delete("errorMessage");
-      url.searchParams.delete("all_keys");
-      url.searchParams.delete("transactionHashes");
-      url.searchParams.delete("txIds");
-      window.history.replaceState({}, "", url.toString());
-    }
-  } catch (e) {
-    console.error("Error handling wallet redirect:", e);
-  }
-
-  // src/index.ts
-  if (typeof window !== "undefined") {
-    window.$$ = convertUnit;
-  }
   return __toCommonJS(src_exports3);
 })();
 /*! Bundled license information:
@@ -4420,15 +4474,17 @@ var near = (() => {
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-if (typeof globalThis.near === 'undefined') {
-  console.warn('No globalThis.near');
-} else {
+try {
   Object.defineProperty(globalThis, 'near', {
-    value: globalThis.near,
-    writable: false,
+    value: near,    
     enumerable: true,
     configurable: false,
   });
+} catch (error) {
+  console.error('Could not define global "near" object', error);
+  throw error;
 }
 
+window.$$ = near.utils.convertUnit;
+
 //# sourceMappingURL=browser.global.js.map