@getpara/core-sdk 2.12.0 → 2.14.0

package/dist/cjs/state/machines/walletStateMachine.js

@@ -0,0 +1,456 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var walletStateMachine_exports = {};
+__export(walletStateMachine_exports, {
+  createWalletStateMachine: () => createWalletStateMachine
+});
+module.exports = __toCommonJS(walletStateMachine_exports);
+var import_xstate = require("xstate");
+var import_polling = require("../actors/polling.js");
+var import_claimWallets = require("../actors/claimWallets.js");
+var import_createWallets = require("../actors/createWallets.js");
+var import_setupAfterLogin = require("../actors/setupAfterLogin.js");
+var import_stateErrorHelpers = require("../../utils/stateErrorHelpers.js");
+var import_connectExternalConnectors = require("../actors/connectExternalConnectors.js");
+var import_createGuestWallets = require("../actors/createGuestWallets.js");
+function createWalletStateMachine(paraCoreInterface) {
+  return (0, import_xstate.setup)({
+    types: {
+      context: {},
+      events: {}
+    },
+    actors: {
+      polling: (0, import_polling.createPollingActor)(paraCoreInterface.pollingService),
+      claimWallets: (0, import_claimWallets.createClaimWalletsActor)(paraCoreInterface.pregenWalletService),
+      createWallets: (0, import_createWallets.createCreateWalletsActor)(paraCoreInterface.walletService),
+      setupAfterLogin: (0, import_setupAfterLogin.createSetupAfterLoginActor)(paraCoreInterface),
+      connectParaConnectors: (0, import_connectExternalConnectors.createConnectParaConnectorsActor)(paraCoreInterface.externalWalletService),
+      createGuestWallets: (0, import_createGuestWallets.createCreateGuestWalletsActor)(paraCoreInterface.pregenWalletService)
+    },
+    actions: {
+      setPollingCallbacks: (0, import_xstate.assign)({
+        pollingCallbacks: ({ event }) => {
+          if ("data" in event && event.data && typeof event.data === "object" && "pollingCallbacks" in event.data) {
+            return event.data.pollingCallbacks || null;
+          }
+          return null;
+        }
+      }),
+      incrementWalletRetry: (0, import_xstate.assign)({
+        retryAttempts: ({ context }, params) => {
+          var _a;
+          const newCount = (((_a = context.retryAttempts) == null ? void 0 : _a[params.type]) || 0) + 1;
+          paraCoreInterface.devLog(`[wallet] Retry ${params.type}: attempt ${newCount}/3`);
+          return __spreadProps(__spreadValues({}, context.retryAttempts), {
+            [params.type]: newCount
+          });
+        }
+      })
+    },
+    guards: {
+      canRetryClaiming: ({ context }) => {
+        var _a;
+        return (((_a = context.retryAttempts) == null ? void 0 : _a.claiming) || 0) < 3;
+      },
+      canRetryCreating: ({ context }) => {
+        var _a;
+        return (((_a = context.retryAttempts) == null ? void 0 : _a.creating) || 0) < 3;
+      },
+      canRetryConnecting: ({ context }) => {
+        var _a;
+        return (((_a = context.retryAttempts) == null ? void 0 : _a.connecting) || 0) < 3;
+      },
+      isNoWalletConfig: () => paraCoreInterface.isNoWalletConfig,
+      isExternalWalletConnectionOnly: () => paraCoreInterface.externalWalletService.externalWalletConnectionType === "CONNECTION_ONLY" || paraCoreInterface.externalWalletService.externalWalletConnectionType === "VERIFICATION",
+      isNewUser: ({ context }) => {
+        var _a;
+        return ((_a = context.authData) == null ? void 0 : _a.isNewUser) || false;
+      },
+      shouldAutoCreate: ({ context }) => {
+        var _a;
+        return ((_a = context.authData) == null ? void 0 : _a.shouldAutoCreateWallets) || false;
+      },
+      needsWallets: ({ context }) => context.needsWallet,
+      isLegacyOrEnclaveLogin: ({ context }) => {
+        var _a, _b;
+        const stage = (_b = (_a = context.authData) == null ? void 0 : _a.authStateResult) == null ? void 0 : _b.stage;
+        return stage === "login" || stage === "done" || stage === "verify" && paraCoreInterface.authService.isEnclaveUser;
+      },
+      hasPreviousWalletsResult: ({ context }) => context.newWalletsResult !== null,
+      isWalletsAlreadySetUp: ({ context }) => {
+        var _a, _b;
+        const stage = (_b = (_a = context.authData) == null ? void 0 : _a.authStateResult) == null ? void 0 : _b.stage;
+        const isLogin = stage === "login" || stage === "done";
+        if (!isLogin) return false;
+        const currentIds = paraCoreInterface.walletService.currentWalletIdsArray;
+        if (currentIds.length === 0) return false;
+        return currentIds.every(([walletId]) => {
+          const wallet = paraCoreInterface.walletService.wallets[walletId];
+          return wallet && !!wallet.signer;
+        });
+      },
+      // Check if the auth state is guest mode
+      isGuestMode: ({ context }) => {
+        var _a;
+        return ((_a = context.authData) == null ? void 0 : _a.isGuestMode) || false;
+      },
+      // Check if the user actually needs guest wallets created
+      needsGuestWallets: () => !paraCoreInterface.pregenWalletService.isGuestMode,
+      // Check if the user should claim guest wallets
+      shouldClaimGuestWallets: () => paraCoreInterface.pregenWalletService.isGuestMode
+    }
+  }).createMachine({
+    id: "wallets",
+    initial: "checking_wallet_state",
+    context: ({ input }) => ({
+      needsWallet: false,
+      newWalletsResult: (input == null ? void 0 : input.previousWalletsResult) || null,
+      temporaryShares: null,
+      pollingCallbacks: null,
+      error: null,
+      authData: {
+        isNewUser: (input == null ? void 0 : input.isNewUser) || false,
+        authStateResult: (input == null ? void 0 : input.authStateResult) || null,
+        shouldAutoCreateWallets: (input == null ? void 0 : input.shouldAutoCreateWallets) || false,
+        skipSessionRefreshOnSetup: (input == null ? void 0 : input.skipSessionRefreshOnSetup) || false,
+        isGuestMode: (input == null ? void 0 : input.isGuestMode) || false
+      },
+      guestWallets: null,
+      retryAttempts: {}
+    }),
+    states: {
+      checking_wallet_state: {
+        always: [
+          {
+            target: "creating_guest_wallets",
+            guard: (0, import_xstate.and)(["isGuestMode", "needsGuestWallets"])
+          },
+          {
+            target: "guest_mode",
+            guard: (0, import_xstate.and)(["isGuestMode"])
+          },
+          {
+            target: "no_wallets_needed",
+            guard: (0, import_xstate.or)(["isNoWalletConfig", "isExternalWalletConnectionOnly"])
+          },
+          {
+            // Skip claiming if we already have wallet results from a previous attempt
+            target: "creating_wallets",
+            guard: (0, import_xstate.and)(["hasPreviousWalletsResult", (0, import_xstate.or)(["isNewUser", "shouldAutoCreate"])])
+          },
+          {
+            target: "claiming_wallets",
+            guard: (0, import_xstate.and)([(0, import_xstate.or)(["isNewUser", "shouldClaimGuestWallets"]), "shouldAutoCreate"])
+          },
+          {
+            target: "needs_wallets",
+            guard: "isNewUser"
+          },
+          {
+            // Wallets already set up (e.g., by loginWithPasskey on mobile) — still
+            // go through creating_wallets so any missing provider-required types
+            // get created. createWalletPerType is idempotent (checks #getMissingTypes).
+            target: "creating_wallets",
+            guard: "isWalletsAlreadySetUp"
+          },
+          {
+            target: "waiting_for_wallets",
+            guard: "isLegacyOrEnclaveLogin"
+          },
+          {
+            target: "connecting_para_connectors"
+          }
+        ]
+      },
+      needs_wallets: {
+        on: {
+          WAIT_FOR_WALLET_CREATION: {
+            target: "claiming_wallets",
+            actions: "setPollingCallbacks"
+          }
+        }
+      },
+      creating_guest_wallets: {
+        invoke: {
+          src: "createGuestWallets",
+          onDone: [
+            {
+              target: "guest_mode",
+              actions: (0, import_xstate.assign)({
+                guestWallets: ({ event }) => {
+                  return event.output || null;
+                }
+              })
+            }
+          ],
+          onError: {
+            target: "error",
+            actions: (0, import_xstate.assign)({
+              error: ({ event }) => (0, import_stateErrorHelpers.formatStateError)(event.error, "Failed to create guest wallets")
+            })
+          }
+        }
+      },
+      claiming_wallets: {
+        invoke: {
+          src: "claimWallets",
+          input: ({ context }) => {
+            var _a, _b;
+            return { retryCount: (_b = (_a = context.retryAttempts) == null ? void 0 : _a.claiming) != null ? _b : 0 };
+          },
+          onDone: [
+            {
+              target: "creating_wallets",
+              actions: (0, import_xstate.assign)({
+                newWalletsResult: ({ event }) => {
+                  return event.output || null;
+                }
+              }),
+              guard: (0, import_xstate.or)(["isNewUser", "needsWallets"])
+            },
+            {
+              target: "connecting_para_connectors"
+            }
+          ],
+          onError: [
+            {
+              target: "claiming_wallets",
+              guard: "canRetryClaiming",
+              actions: [{ type: "incrementWalletRetry", params: { type: "claiming" } }]
+            },
+            {
+              target: "error",
+              actions: (0, import_xstate.assign)({
+                error: ({ event }) => (0, import_stateErrorHelpers.formatStateError)(event.error, "Failed to claim wallets")
+              })
+            }
+          ]
+        }
+      },
+      creating_wallets: {
+        invoke: {
+          src: "createWallets",
+          input: ({ context }) => {
+            var _a, _b;
+            return __spreadProps(__spreadValues({}, context.newWalletsResult), { retryCount: (_b = (_a = context.retryAttempts) == null ? void 0 : _a.creating) != null ? _b : 0 });
+          },
+          onDone: {
+            target: "connecting_para_connectors",
+            actions: (0, import_xstate.assign)({
+              newWalletsResult: ({ event }) => {
+                return event.output || null;
+              }
+            })
+          },
+          onError: [
+            {
+              target: "creating_wallets",
+              guard: "canRetryCreating",
+              actions: [{ type: "incrementWalletRetry", params: { type: "creating" } }]
+            },
+            {
+              target: "error",
+              actions: (0, import_xstate.assign)({
+                error: ({ event }) => (0, import_stateErrorHelpers.formatStateError)(event.error, "Failed to create wallets")
+              })
+            }
+          ]
+        }
+      },
+      waiting_for_wallets: {
+        invoke: {
+          src: "polling",
+          input: ({ context, self }) => {
+            var _a;
+            return {
+              checkCondition: () => __async(this, null, function* () {
+                try {
+                  return yield paraCoreInterface.pollingService.waitForWallets({ parent: self })();
+                } catch (error) {
+                  throw new Error(`Wallet polling failed: ${(0, import_stateErrorHelpers.extractErrorMessage)(error, "Unknown error")}`);
+                }
+              }),
+              onPoll: () => {
+                var _a2, _b;
+                return (_b = (_a2 = context.pollingCallbacks) == null ? void 0 : _a2.onPoll) == null ? void 0 : _b.call(_a2);
+              },
+              onCancel: () => {
+                var _a2, _b;
+                return (_b = (_a2 = context.pollingCallbacks) == null ? void 0 : _a2.onCancel) == null ? void 0 : _b.call(_a2);
+              },
+              isCanceled: ((_a = context.pollingCallbacks) == null ? void 0 : _a.isCanceled) || (() => false),
+              id: "waitingForWallets"
+            };
+          },
+          onError: {
+            target: "error",
+            actions: (0, import_xstate.assign)({
+              error: ({ event }) => (0, import_stateErrorHelpers.formatStateError)(event.error, "Wallet polling failed")
+            })
+          }
+        },
+        entry: "setPollingCallbacks",
+        on: {
+          SET_NEEDS_WALLET: {
+            actions: (0, import_xstate.assign)({
+              needsWallet: ({ event }) => {
+                if ("data" in event && event.data && typeof event.data === "object" && "needsWallet" in event.data) {
+                  return Boolean(event.data.needsWallet);
+                }
+                return false;
+              }
+            })
+          },
+          SET_TEMPORARY_SHARES: {
+            actions: (0, import_xstate.assign)({
+              temporaryShares: ({ event }) => {
+                if ("data" in event && event.data && typeof event.data === "object" && "temporaryShares" in event.data) {
+                  return event.data.temporaryShares;
+                }
+                return null;
+              }
+            })
+          },
+          COMPLETE: [
+            {
+              target: "needs_wallets",
+              guard: "needsWallets"
+            },
+            {
+              target: "setting_up_after_login"
+            }
+          ],
+          CANCEL: [
+            {
+              target: "checking_wallet_state"
+            }
+          ],
+          ERROR: {
+            target: "error",
+            actions: (0, import_xstate.assign)({
+              error: ({ event }) => (0, import_stateErrorHelpers.formatStateError)(event.error, "Wallet polling failed")
+            })
+          }
+        }
+      },
+      setting_up_after_login: {
+        invoke: {
+          src: "setupAfterLogin",
+          input: ({ context }) => {
+            var _a;
+            return {
+              temporaryShares: context.temporaryShares,
+              skipSessionRefresh: ((_a = context.authData) == null ? void 0 : _a.skipSessionRefreshOnSetup) || false
+            };
+          },
+          onDone: {
+            target: "claiming_wallets",
+            actions: (0, import_xstate.assign)({
+              // Reset temporary shares after successful setup
+              temporaryShares: null
+            })
+          },
+          onError: {
+            target: "error",
+            actions: (0, import_xstate.assign)({
+              error: ({ event }) => (0, import_stateErrorHelpers.formatStateError)(event.error, "Failed to setup after login")
+            })
+          }
+        }
+      },
+      connecting_para_connectors: {
+        invoke: {
+          src: "connectParaConnectors",
+          input: ({ context }) => {
+            var _a, _b;
+            return { retryCount: (_b = (_a = context.retryAttempts) == null ? void 0 : _a.connecting) != null ? _b : 0 };
+          },
+          onDone: {
+            target: "wallets_ready"
+          },
+          onError: [
+            {
+              target: "connecting_para_connectors",
+              guard: "canRetryConnecting",
+              actions: [{ type: "incrementWalletRetry", params: { type: "connecting" } }]
+            },
+            {
+              target: "error",
+              actions: (0, import_xstate.assign)({
+                error: ({ event }) => (0, import_stateErrorHelpers.formatStateError)(event.error, "Failed to connect Para connectors")
+              })
+            }
+          ]
+        }
+      },
+      no_wallets_needed: {
+        type: "final"
+      },
+      wallets_ready: {
+        type: "final"
+      },
+      guest_mode: {
+        type: "final"
+      },
+      error: {
+        type: "final"
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWalletStateMachine
+});

package/dist/cjs/state/types/auth.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 auth_exports = {};
+module.exports = __toCommonJS(auth_exports);

package/dist/cjs/state/types/core.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 core_exports = {};
+module.exports = __toCommonJS(core_exports);

package/dist/cjs/state/types/wallet.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 wallet_exports = {};
+module.exports = __toCommonJS(wallet_exports);

package/dist/cjs/types/{auth.js → accountLinking.js}

@@ -15,11 +15,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var auth_exports = {};
-__export(auth_exports, {
+var accountLinking_exports = {};
+__export(accountLinking_exports, {
   AccountLinkError: () => AccountLinkError
 });
-module.exports = __toCommonJS(auth_exports);
+module.exports = __toCommonJS(accountLinking_exports);
 var AccountLinkError = /* @__PURE__ */ ((AccountLinkError2) => {
   AccountLinkError2["NotAuthenticated"] = "No user is currently authenticated";
   AccountLinkError2["Conflict"] = "Account already linked";

package/dist/cjs/types/authState.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 authState_exports = {};
+module.exports = __toCommonJS(authState_exports);

package/dist/cjs/types/coreApi.js

@@ -72,7 +72,9 @@ const PARA_CORE_METHODS = [
   "getLinkedAccounts",
   "accountLinkInProgress",
   "addCredential",
-  "exportPrivateKey"
+  "exportPrivateKey",
+  "authenticateWithEmailOrPhone",
+  "authenticateWithOAuth"
 ];
 const PARA_INTERNAL_METHODS = [
   "linkAccount",

package/dist/cjs/types/index.js

@@ -14,7 +14,7 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var types_exports = {};
 module.exports = __toCommonJS(types_exports);
-__reExport(types_exports, require("./auth.js"), module.exports);
+__reExport(types_exports, require("./accountLinking.js"), module.exports);
 __reExport(types_exports, require("./config.js"), module.exports);
 __reExport(types_exports, require("./coreApi.js"), module.exports);
 __reExport(types_exports, require("./wallet.js"), module.exports);
@@ -23,7 +23,7 @@ __reExport(types_exports, require("./popup.js"), module.exports);
 __reExport(types_exports, require("./events.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./auth.js"),
+  ...require("./accountLinking.js"),
   ...require("./config.js"),
   ...require("./coreApi.js"),
   ...require("./wallet.js"),

package/dist/cjs/types/serviceInterfaces.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 serviceInterfaces_exports = {};
+module.exports = __toCommonJS(serviceInterfaces_exports);

package/dist/cjs/types/util.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 util_exports = {};
+module.exports = __toCommonJS(util_exports);

package/dist/cjs/utils/formatting.js

@@ -88,6 +88,9 @@ function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
   return (0, import_ripemd160.ripemd160)((0, import_sha256.sha256)(pubkeyData));
 }
 function getCosmosAddress(publicKey, prefix) {
+  if (!publicKey || publicKey.length === 0) {
+    return "";
+  }
   const uncompressedPublicKey = new Uint8Array(
     Buffer.from(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey, "hex")
   );
@@ -98,6 +101,9 @@ function truncateAddress(str, addressType, {
   prefix = addressType === "COSMOS" ? "cosmos" : void 0,
   targetLength
 } = {}) {
+  if (!str || str.length === 0) {
+    return "";
+  }
   const minimum = addressType === "COSMOS" ? prefix.length : addressType === "EVM" ? 2 : 0;
   const margin = targetLength !== void 0 ? (targetLength - minimum) / 2 : 4;
   return `${str.slice(0, minimum + margin)}...${str.slice(-1 * margin)}`;

package/dist/cjs/utils/retryBackoff.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retryBackoff_exports = {};
+__export(retryBackoff_exports, {
+  retryDelay: () => retryDelay,
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(retryBackoff_exports);
+const retryDelay = (attempt) => Math.min(100 * Math.pow(2, attempt), 2e3);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  retryDelay,
+  sleep
+});