@column-org/wallet-sdk 1.1.5 → 1.1.7

package/dist/index.js

@@ -5,9 +5,15 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -27,10 +33,967 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../node_modules/expo-modules-core/src/NativeModulesProxy.ts
+var NativeModulesProxy_default;
+var init_NativeModulesProxy = __esm({
+  "../node_modules/expo-modules-core/src/NativeModulesProxy.ts"() {
+    "use strict";
+    NativeModulesProxy_default = {};
+  }
+});
+
+// ../node_modules/expo-modules-core/src/TurboModuleToExpoModuleProxy.ts
+function createTurboModuleToExpoProxy(turboModule, name2) {
+  return null;
+}
+var init_TurboModuleToExpoModuleProxy = __esm({
+  "../node_modules/expo-modules-core/src/TurboModuleToExpoModuleProxy.ts"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/expo-modules-core/src/ensureNativeModulesAreInstalled.ts
+function ensureNativeModulesAreInstalled() {
+}
+var init_ensureNativeModulesAreInstalled = __esm({
+  "../node_modules/expo-modules-core/src/ensureNativeModulesAreInstalled.ts"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/expo-modules-core/src/requireNativeModule.ts
+function requireNativeModule(moduleName) {
+  const nativeModule = requireOptionalNativeModule(moduleName);
+  if (!nativeModule) {
+    throw new Error(`Cannot find native module '${moduleName}'`);
+  }
+  return nativeModule;
+}
+function requireOptionalNativeModule(moduleName) {
+  ensureNativeModulesAreInstalled();
+  try {
+    return globalThis.expo?.modules?.[moduleName] ?? NativeModulesProxy_default[moduleName] ?? createTurboModuleToExpoProxy(import_react_native.TurboModuleRegistry.get(moduleName), moduleName) ?? null;
+  } catch (e) {
+    const error = e;
+    console.warn(`An error occurred while requiring the '${moduleName}' module: ${error.message}`);
+    return null;
+  }
+}
+var import_react_native;
+var init_requireNativeModule = __esm({
+  "../node_modules/expo-modules-core/src/requireNativeModule.ts"() {
+    "use strict";
+    import_react_native = require("react-native");
+    init_NativeModulesProxy();
+    init_TurboModuleToExpoModuleProxy();
+    init_ensureNativeModulesAreInstalled();
+  }
+});
+
+// ../node_modules/expo-modules-core/src/sweet/NativeJSLogger.ts
+var NativeJSLogger_default;
+var init_NativeJSLogger = __esm({
+  "../node_modules/expo-modules-core/src/sweet/NativeJSLogger.ts"() {
+    "use strict";
+    init_requireNativeModule();
+    NativeJSLogger_default = requireOptionalNativeModule("ExpoModulesCoreJSLogger");
+  }
+});
+
+// ../node_modules/expo-modules-core/src/environment/browser.ts
+var isDOMAvailable, canUseEventListeners, canUseViewport, isAsyncDebugging;
+var init_browser = __esm({
+  "../node_modules/expo-modules-core/src/environment/browser.ts"() {
+    "use strict";
+    isDOMAvailable = false;
+    canUseEventListeners = false;
+    canUseViewport = false;
+    isAsyncDebugging = false;
+    if (__DEV__) {
+      isAsyncDebugging = !global.nativeExtensions && !global.nativeCallSyncHook && !global.RN$Bridgeless;
+    }
+  }
+});
+
+// ../node_modules/expo-modules-core/src/Platform.ts
+var import_react_native2, nativeSelect, Platform, Platform_default;
+var init_Platform = __esm({
+  "../node_modules/expo-modules-core/src/Platform.ts"() {
+    "use strict";
+    import_react_native2 = require("react-native");
+    init_browser();
+    if (__DEV__ && typeof process.env.EXPO_OS === "undefined") {
+      console.warn(
+        `The global process.env.EXPO_OS is not defined. This should be inlined by babel-preset-expo during transformation.`
+      );
+    }
+    nativeSelect = typeof window !== "undefined" ? import_react_native2.Platform.select : (
+      // process.env.EXPO_OS is injected by `babel-preset-expo` and available in both client and `react-server` environments.
+      // Opt to use the env var when possible, and fallback to the React Native Platform module when it's not (arbitrary bundlers and transformers).
+      function select(specifics) {
+        if (!process.env.EXPO_OS) return void 0;
+        if (specifics.hasOwnProperty(process.env.EXPO_OS)) {
+          return specifics[process.env.EXPO_OS];
+        } else if (process.env.EXPO_OS !== "web" && specifics.hasOwnProperty("native")) {
+          return specifics.native;
+        } else if (specifics.hasOwnProperty("default")) {
+          return specifics.default;
+        }
+        return void 0;
+      }
+    );
+    Platform = {
+      /**
+       * Denotes the currently running platform.
+       * Can be one of ios, android, web.
+       */
+      OS: process.env.EXPO_OS || import_react_native2.Platform.OS,
+      /**
+       * Returns the value with the matching platform.
+       * Object keys can be any of ios, android, native, web, default.
+       *
+       * @ios ios, native, default
+       * @android android, native, default
+       * @web web, default
+       */
+      select: nativeSelect,
+      /**
+       * Denotes if the DOM API is available in the current environment.
+       * The DOM is not available in native React runtimes and Node.js.
+       */
+      isDOMAvailable,
+      /**
+       * Denotes if the current environment can attach event listeners
+       * to the window. This will return false in native React
+       * runtimes and Node.js.
+       */
+      canUseEventListeners,
+      /**
+       * Denotes if the current environment can inspect properties of the
+       * screen on which the current window is being rendered. This will
+       * return false in native React runtimes and Node.js.
+       */
+      canUseViewport,
+      /**
+       * If the JavaScript is being executed in a remote JavaScript environment.
+       * When `true`, synchronous native invocations cannot be executed.
+       */
+      isAsyncDebugging
+    };
+    Platform_default = Platform;
+  }
+});
+
+// ../node_modules/expo-modules-core/src/errors/CodedError.ts
+var CodedError;
+var init_CodedError = __esm({
+  "../node_modules/expo-modules-core/src/errors/CodedError.ts"() {
+    "use strict";
+    CodedError = class extends Error {
+      code;
+      info;
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+      }
+    };
+  }
+});
+
+// ../node_modules/expo-modules-core/src/sweet/setUpJsLogger.fx.ts
+var init_setUpJsLogger_fx = __esm({
+  "../node_modules/expo-modules-core/src/sweet/setUpJsLogger.fx.ts"() {
+    "use strict";
+    init_NativeJSLogger();
+    init_Platform();
+    init_CodedError();
+    if (__DEV__ && (Platform_default.OS === "android" || Platform_default.OS === "ios") && NativeJSLogger_default) {
+      const onNewException = {
+        eventName: "ExpoModulesCoreJSLogger.onNewError",
+        action: console.error
+      };
+      const onNewWarning = {
+        eventName: "ExpoModulesCoreJSLogger.onNewWarning",
+        action: console.warn
+      };
+      const onNewDebug = {
+        eventName: "ExpoModulesCoreJSLogger.onNewDebug",
+        action: console.debug
+      };
+      const onNewInfo = {
+        eventName: "ExpoModulesCoreJSLogger.onNewInfo",
+        action: console.info
+      };
+      const onNewTrace = {
+        eventName: "ExpoModulesCoreJSLogger.onNewTrace",
+        action: console.trace
+      };
+      const listeners = [
+        onNewException,
+        onNewWarning,
+        onNewDebug,
+        onNewInfo,
+        onNewTrace
+      ];
+      for (const listener of listeners) {
+        NativeJSLogger_default.addListener(listener.eventName, ({ message }) => {
+          listener.action(message);
+        });
+      }
+    }
+    globalThis.ExpoModulesCore_CodedError = CodedError;
+  }
+});
+
+// ../node_modules/expo-modules-core/src/errors/UnavailabilityError.ts
+var UnavailabilityError;
+var init_UnavailabilityError = __esm({
+  "../node_modules/expo-modules-core/src/errors/UnavailabilityError.ts"() {
+    "use strict";
+    init_CodedError();
+    init_Platform();
+    UnavailabilityError = class extends CodedError {
+      constructor(moduleName, propertyName) {
+        super(
+          "ERR_UNAVAILABLE",
+          `The method or property ${moduleName}.${propertyName} is not available on ${Platform_default.OS}, are you sure you've linked all the native dependencies properly?`
+        );
+      }
+    };
+  }
+});
+
+// ../node_modules/expo-modules-core/src/registerWebModule.ts
+var init_registerWebModule = __esm({
+  "../node_modules/expo-modules-core/src/registerWebModule.ts"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/expo-modules-core/src/TypedArrays.types.ts
+var init_TypedArrays_types = __esm({
+  "../node_modules/expo-modules-core/src/TypedArrays.types.ts"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/expo-modules-core/src/PermissionsInterface.ts
+var init_PermissionsInterface = __esm({
+  "../node_modules/expo-modules-core/src/PermissionsInterface.ts"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/expo-modules-core/src/PermissionsHook.ts
+var import_react;
+var init_PermissionsHook = __esm({
+  "../node_modules/expo-modules-core/src/PermissionsHook.ts"() {
+    "use strict";
+    "use client";
+    import_react = require("react");
+  }
+});
+
+// ../node_modules/expo-modules-core/src/Refs.ts
+var import_react2;
+var init_Refs = __esm({
+  "../node_modules/expo-modules-core/src/Refs.ts"() {
+    "use strict";
+    import_react2 = require("react");
+  }
+});
+
+// ../node_modules/expo-modules-core/src/hooks/useReleasingSharedObject.ts
+var import_react3;
+var init_useReleasingSharedObject = __esm({
+  "../node_modules/expo-modules-core/src/hooks/useReleasingSharedObject.ts"() {
+    "use strict";
+    "use client";
+    import_react3 = require("react");
+  }
+});
+
+// ../node_modules/expo-modules-core/src/reload.ts
+var init_reload = __esm({
+  "../node_modules/expo-modules-core/src/reload.ts"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/invariant/invariant.js
+var require_invariant = __commonJS({
+  "../node_modules/invariant/invariant.js"(exports2, module2) {
+    "use strict";
+    var NODE_ENV = process.env.NODE_ENV;
+    var invariant2 = function(condition, format, a, b, c, d, e, f) {
+      if (NODE_ENV !== "production") {
+        if (format === void 0) {
+          throw new Error("invariant requires an error message argument");
+        }
+      }
+      if (!condition) {
+        var error;
+        if (format === void 0) {
+          error = new Error(
+            "Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."
+          );
+        } else {
+          var args = [a, b, c, d, e, f];
+          var argIndex = 0;
+          error = new Error(
+            format.replace(/%s/g, function() {
+              return args[argIndex++];
+            })
+          );
+          error.name = "Invariant Violation";
+        }
+        error.framesToPop = 1;
+        throw error;
+      }
+    };
+    module2.exports = invariant2;
+  }
+});
+
+// ../node_modules/expo-modules-core/src/index.ts
+var init_src = __esm({
+  "../node_modules/expo-modules-core/src/index.ts"() {
+    "use strict";
+    init_setUpJsLogger_fx();
+    init_Platform();
+    init_requireNativeModule();
+    init_registerWebModule();
+    init_TypedArrays_types();
+    init_PermissionsInterface();
+    init_PermissionsHook();
+    init_Refs();
+    init_useReleasingSharedObject();
+    init_reload();
+    init_CodedError();
+    init_UnavailabilityError();
+  }
+});
+
+// ../node_modules/expo-constants/build/Constants.types.js
+var AppOwnership, ExecutionEnvironment, UserInterfaceIdiom;
+var init_Constants_types = __esm({
+  "../node_modules/expo-constants/build/Constants.types.js"() {
+    "use strict";
+    (function(AppOwnership2) {
+      AppOwnership2["Expo"] = "expo";
+    })(AppOwnership || (AppOwnership = {}));
+    (function(ExecutionEnvironment2) {
+      ExecutionEnvironment2["Bare"] = "bare";
+      ExecutionEnvironment2["Standalone"] = "standalone";
+      ExecutionEnvironment2["StoreClient"] = "storeClient";
+    })(ExecutionEnvironment || (ExecutionEnvironment = {}));
+    (function(UserInterfaceIdiom2) {
+      UserInterfaceIdiom2["Handset"] = "handset";
+      UserInterfaceIdiom2["Tablet"] = "tablet";
+      UserInterfaceIdiom2["Desktop"] = "desktop";
+      UserInterfaceIdiom2["TV"] = "tv";
+      UserInterfaceIdiom2["Unsupported"] = "unsupported";
+    })(UserInterfaceIdiom || (UserInterfaceIdiom = {}));
+  }
+});
+
+// ../node_modules/expo-constants/build/ExponentConstants.js
+var ExponentConstants_default;
+var init_ExponentConstants = __esm({
+  "../node_modules/expo-constants/build/ExponentConstants.js"() {
+    "use strict";
+    init_src();
+    ExponentConstants_default = requireOptionalNativeModule("ExponentConstants");
+  }
+});
+
+// ../node_modules/expo-constants/build/Constants.js
+var Constants_exports = {};
+__export(Constants_exports, {
+  AppOwnership: () => AppOwnership,
+  ExecutionEnvironment: () => ExecutionEnvironment,
+  UserInterfaceIdiom: () => UserInterfaceIdiom,
+  default: () => Constants_default
+});
+function isEmbeddedManifest(manifest) {
+  return !isExpoUpdatesManifest(manifest);
+}
+function isExpoUpdatesManifest(manifest) {
+  return "metadata" in manifest;
+}
+function getManifest(suppressWarning = false) {
+  if (!rawManifest) {
+    const invalidManifestType = rawManifest === null ? "null" : "undefined";
+    if (nativeConstants.executionEnvironment === ExecutionEnvironment.Bare && import_react_native3.Platform.OS !== "web") {
+      if (!suppressWarning) {
+        console.warn(`Constants.manifest is ${invalidManifestType} because the embedded app.config could not be read. Ensure that you have installed the expo-constants build scripts if you need to read from Constants.manifest.`);
+      }
+    } else if (nativeConstants.executionEnvironment === ExecutionEnvironment.StoreClient || nativeConstants.executionEnvironment === ExecutionEnvironment.Standalone) {
+      throw new CodedError("ERR_CONSTANTS_MANIFEST_UNAVAILABLE", `Constants.manifest is ${invalidManifestType}, must be an object.`);
+    }
+  }
+  return rawManifest;
+}
+var import_react_native3, ExpoUpdates, rawUpdatesManifest, rawDevLauncherManifest, rawAppConfig, rawManifest, name, appOwnership, nativeConstants, constants, Constants_default;
+var init_Constants = __esm({
+  "../node_modules/expo-constants/build/Constants.js"() {
+    "use strict";
+    init_src();
+    import_react_native3 = require("react-native");
+    init_Constants_types();
+    init_ExponentConstants();
+    if (!ExponentConstants_default) {
+      console.warn("No native ExponentConstants module found, are you sure the expo-constants's module is linked properly?");
+    }
+    ExpoUpdates = requireOptionalNativeModule("ExpoUpdates");
+    rawUpdatesManifest = null;
+    if (ExpoUpdates) {
+      let updatesManifest;
+      if (ExpoUpdates.manifest) {
+        updatesManifest = ExpoUpdates.manifest;
+      } else if (ExpoUpdates.manifestString) {
+        updatesManifest = JSON.parse(ExpoUpdates.manifestString);
+      }
+      if (updatesManifest && Object.keys(updatesManifest).length > 0) {
+        rawUpdatesManifest = updatesManifest;
+      }
+    }
+    rawDevLauncherManifest = null;
+    if (import_react_native3.NativeModules.EXDevLauncher) {
+      let devLauncherManifest;
+      if (import_react_native3.NativeModules.EXDevLauncher.manifestString) {
+        devLauncherManifest = JSON.parse(import_react_native3.NativeModules.EXDevLauncher.manifestString);
+      }
+      if (devLauncherManifest && Object.keys(devLauncherManifest).length > 0) {
+        rawDevLauncherManifest = devLauncherManifest;
+      }
+    }
+    rawAppConfig = null;
+    if (ExponentConstants_default && ExponentConstants_default.manifest) {
+      const appConfig = ExponentConstants_default.manifest;
+      if (typeof appConfig === "string") {
+        rawAppConfig = JSON.parse(appConfig);
+      } else {
+        rawAppConfig = appConfig;
+      }
+    }
+    rawManifest = rawUpdatesManifest ?? rawDevLauncherManifest ?? rawAppConfig;
+    ({ name, appOwnership, ...nativeConstants } = ExponentConstants_default || {});
+    constants = {
+      ...nativeConstants,
+      // Ensure this is null in bare workflow
+      appOwnership: appOwnership ?? null
+    };
+    Object.defineProperties(constants, {
+      /**
+       * Use `manifest` property by default.
+       * This property is only used for internal purposes.
+       * It behaves similarly to the original one, but suppresses warning upon no manifest available.
+       * `expo-asset` uses it to prevent users from seeing mentioned warning.
+       */
+      __unsafeNoWarnManifest: {
+        get() {
+          const maybeManifest = getManifest(true);
+          if (!maybeManifest || !isEmbeddedManifest(maybeManifest)) {
+            return null;
+          }
+          return maybeManifest;
+        },
+        enumerable: false
+      },
+      __unsafeNoWarnManifest2: {
+        get() {
+          const maybeManifest = getManifest(true);
+          if (!maybeManifest || !isExpoUpdatesManifest(maybeManifest)) {
+            return null;
+          }
+          return maybeManifest;
+        },
+        enumerable: false
+      },
+      manifest: {
+        get() {
+          const maybeManifest = getManifest();
+          if (!maybeManifest || !isEmbeddedManifest(maybeManifest)) {
+            return null;
+          }
+          return maybeManifest;
+        },
+        enumerable: true
+      },
+      manifest2: {
+        get() {
+          const maybeManifest = getManifest();
+          if (!maybeManifest || !isExpoUpdatesManifest(maybeManifest)) {
+            return null;
+          }
+          return maybeManifest;
+        },
+        enumerable: true
+      },
+      expoConfig: {
+        get() {
+          const maybeManifest = getManifest(true);
+          if (!maybeManifest) {
+            return null;
+          }
+          if (ExpoUpdates && ExpoUpdates.isEmbeddedLaunch) {
+            return rawAppConfig;
+          }
+          if (isExpoUpdatesManifest(maybeManifest)) {
+            return maybeManifest.extra?.expoClient ?? null;
+          } else if (isEmbeddedManifest(maybeManifest)) {
+            return maybeManifest;
+          }
+          return null;
+        },
+        enumerable: true
+      },
+      expoGoConfig: {
+        get() {
+          const maybeManifest = getManifest(true);
+          if (!maybeManifest) {
+            return null;
+          }
+          if (isExpoUpdatesManifest(maybeManifest)) {
+            return maybeManifest.extra?.expoGo ?? null;
+          } else if (isEmbeddedManifest(maybeManifest)) {
+            return maybeManifest;
+          }
+          return null;
+        },
+        enumerable: true
+      },
+      easConfig: {
+        get() {
+          const maybeManifest = getManifest(true);
+          if (!maybeManifest) {
+            return null;
+          }
+          if (isExpoUpdatesManifest(maybeManifest)) {
+            return maybeManifest.extra?.eas ?? null;
+          } else if (isEmbeddedManifest(maybeManifest)) {
+            return maybeManifest;
+          }
+          return null;
+        },
+        enumerable: true
+      },
+      __rawManifest_TEST: {
+        get() {
+          return rawManifest;
+        },
+        set(value) {
+          rawManifest = value;
+        },
+        enumerable: false
+      }
+    });
+    Constants_default = constants;
+  }
+});
+
+// ../node_modules/expo-linking/build/ExpoLinking.js
+var ExpoLinking, ExpoLinking_default;
+var init_ExpoLinking = __esm({
+  "../node_modules/expo-linking/build/ExpoLinking.js"() {
+    "use strict";
+    init_src();
+    ExpoLinking = requireNativeModule("ExpoLinking");
+    ExpoLinking_default = ExpoLinking;
+  }
+});
+
+// ../node_modules/expo-linking/build/RNLinking.js
+var import_react_native4, RNLinking_default;
+var init_RNLinking = __esm({
+  "../node_modules/expo-linking/build/RNLinking.js"() {
+    "use strict";
+    import_react_native4 = require("react-native");
+    RNLinking_default = import_react_native4.Linking;
+  }
+});
+
+// ../node_modules/expo-linking/build/Schemes.js
+function hasCustomScheme() {
+  if (Constants_default.executionEnvironment === ExecutionEnvironment.Bare) {
+    return true;
+  } else if (Constants_default.executionEnvironment === ExecutionEnvironment.Standalone) {
+    const manifestSchemes = collectManifestSchemes();
+    return !!manifestSchemes.length;
+  }
+  return false;
+}
+function getSchemes(config) {
+  if (config) {
+    if (Array.isArray(config.scheme)) {
+      const validate = (value) => {
+        return typeof value === "string";
+      };
+      return config.scheme.filter(validate);
+    } else if (typeof config.scheme === "string") {
+      return [config.scheme];
+    }
+  }
+  return [];
+}
+function collectManifestSchemes() {
+  const platformManifest = Platform_default.select({
+    ios: Constants_default.expoConfig?.ios,
+    android: Constants_default.expoConfig?.android
+  }) ?? {};
+  return getSchemes(Constants_default.expoConfig).concat(getSchemes(platformManifest));
+}
+function getNativeAppIdScheme() {
+  return Platform_default.select({
+    ios: Constants_default.expoConfig?.ios?.bundleIdentifier,
+    // TODO: This may change to android.applicationId in the future.
+    android: Constants_default.expoConfig?.android?.package
+  }) ?? null;
+}
+function hasConstantsManifest() {
+  return !!Object.keys(Constants_default.expoConfig ?? {}).length;
+}
+function resolveScheme(options) {
+  if (Constants_default.executionEnvironment !== ExecutionEnvironment.StoreClient && !hasConstantsManifest()) {
+    throw new Error(`expo-linking needs access to the expo-constants manifest (app.json or app.config.js) to determine what URI scheme to use. Setup the manifest and rebuild: https://github.com/expo/expo/blob/main/packages/expo-constants/README.md`);
+  }
+  const manifestSchemes = collectManifestSchemes();
+  const nativeAppId = getNativeAppIdScheme();
+  if (!manifestSchemes.length) {
+    if (__DEV__ && !options.isSilent) {
+      console.warn(`Linking requires a build-time setting \`scheme\` in the project's Expo config (app.config.js or app.json) for production apps, if it's left blank, your app may crash. The scheme does not apply to development in the Expo client but you should add it as soon as you start working with Linking to avoid creating a broken build. Learn more: ${LINKING_GUIDE_URL}`);
+    } else if (!__DEV__ || Constants_default.executionEnvironment !== ExecutionEnvironment.StoreClient) {
+      throw new Error("Cannot make a deep link into a standalone app with no custom scheme defined");
+    }
+  }
+  if (Constants_default.executionEnvironment === ExecutionEnvironment.StoreClient) {
+    if (options.scheme) {
+      if (EXPO_CLIENT_SCHEMES?.includes(options.scheme)) {
+        return options.scheme;
+      }
+    }
+    return "exp";
+  }
+  const schemes = [...manifestSchemes, nativeAppId].filter(Boolean);
+  if (options.scheme) {
+    if (__DEV__) {
+      if (!schemes.includes(options.scheme) && !options.isSilent) {
+        console.warn(`The provided Linking scheme '${options.scheme}' does not appear in the list of possible URI schemes in your Expo config. Expected one of: ${schemes.map((scheme2) => `'${scheme2}'`).join(", ")}`);
+      }
+    }
+    return options.scheme;
+  }
+  if (!!nativeAppId && !manifestSchemes.length && !options.isSilent) {
+    console.warn(`Linking requires a build-time setting \`scheme\` in the project's Expo config (app.config.js or app.json) for bare or production apps. Manually providing a \`scheme\` property can circumvent this warning. Using native app identifier as the scheme '${nativeAppId}'. Learn more: ${LINKING_GUIDE_URL}`);
+    return nativeAppId;
+  }
+  const [scheme, ...extraSchemes] = manifestSchemes;
+  if (!scheme) {
+    const errorMessage = `Linking requires a build-time setting \`scheme\` in the project's Expo config (app.config.js or app.json) for bare or production apps. Manually providing a \`scheme\` property can circumvent this error. Learn more: ${LINKING_GUIDE_URL}`;
+    throw new Error(errorMessage);
+  }
+  if (extraSchemes.length && !options.isSilent) {
+    console.warn(`Linking found multiple possible URI schemes in your Expo config.
+Using '${scheme}'. Ignoring: ${[
+      ...extraSchemes,
+      nativeAppId
+    ].filter(Boolean).join(", ")}.
+Provide the preferred URI scheme to the Linking API.`);
+  }
+  return scheme;
+}
+var LINKING_GUIDE_URL, EXPO_CLIENT_SCHEMES;
+var init_Schemes = __esm({
+  "../node_modules/expo-linking/build/Schemes.js"() {
+    "use strict";
+    init_Constants();
+    init_src();
+    LINKING_GUIDE_URL = `https://docs.expo.dev/guides/linking/`;
+    EXPO_CLIENT_SCHEMES = Platform_default.select({
+      // Results from `npx uri-scheme list --info-path ios/Exponent/Supporting/Info.plist`
+      ios: [
+        "exp",
+        "exps",
+        "fb1696089354000816",
+        "host.exp.exponent",
+        "com.googleusercontent.apps.603386649315-vp4revvrcgrcjme51ebuhbkbspl048l9"
+      ],
+      // Collected manually
+      android: ["exp", "exps"]
+    });
+  }
+});
+
+// ../node_modules/expo-linking/build/validateURL.js
+function validateURL(url) {
+  (0, import_invariant.default)(typeof url === "string", "Invalid URL: should be a string. Was: " + url);
+  (0, import_invariant.default)(url, "Invalid URL: cannot be empty");
+}
+var import_invariant;
+var init_validateURL = __esm({
+  "../node_modules/expo-linking/build/validateURL.js"() {
+    "use strict";
+    import_invariant = __toESM(require_invariant());
+  }
+});
+
+// ../node_modules/expo-linking/build/createURL.js
+function getHostUri() {
+  if (Constants_default.expoConfig?.hostUri) {
+    return Constants_default.expoConfig.hostUri;
+  } else if (!hasCustomScheme()) {
+    return removeScheme(Constants_default.linkingUri).replace(/\/--($|\/.*$)/, "");
+  } else {
+    return null;
+  }
+}
+function isExpoHosted() {
+  const hostUri = getHostUri();
+  return !!(hostUri && (/^(.*\.)?(expo\.io|exp\.host|exp\.direct|expo\.test|expo\.dev)(:.*)?(\/.*)?$/.test(hostUri) || Constants_default.expoGoConfig?.developer));
+}
+function removeScheme(url) {
+  return url.replace(/^[a-zA-Z0-9+.-]+:\/\//, "");
+}
+function removePort(url) {
+  return url.replace(/(?=([a-zA-Z0-9+.-]+:\/\/)?[^/]):\d+/, "");
+}
+function removeLeadingSlash(url) {
+  return url.replace(/^\//, "");
+}
+function removeTrailingSlashAndQueryString(url) {
+  return url.replace(/\/?\?.*$/, "");
+}
+function ensureLeadingSlash(input, shouldAppend) {
+  const hasSlash = input.startsWith("/");
+  if (hasSlash && !shouldAppend) {
+    return input.substring(1);
+  } else if (!hasSlash && shouldAppend) {
+    return `/${input}`;
+  }
+  return input;
+}
+function createURL(path, { scheme, queryParams = {}, isTripleSlashed = false } = {}) {
+  const resolvedScheme = resolveScheme({ scheme });
+  let hostUri = getHostUri() || "";
+  if (hasCustomScheme() && isExpoHosted()) {
+    hostUri = "";
+  }
+  if (path) {
+    if (isExpoHosted() && hostUri) {
+      path = `/--/${removeLeadingSlash(path)}`;
+    }
+    if (isTripleSlashed && !path.startsWith("/")) {
+      path = `/${path}`;
+    }
+  } else {
+    path = "";
+  }
+  let queryString = "";
+  const queryStringMatchResult = hostUri.match(/(.*)\?(.+)/);
+  if (queryStringMatchResult) {
+    hostUri = queryStringMatchResult[1];
+    queryString = queryStringMatchResult[2];
+    let paramsFromHostUri = {};
+    try {
+      paramsFromHostUri = Object.fromEntries(
+        // @ts-ignore: [Symbol.iterator] is indeed, available on every platform.
+        new URLSearchParams(queryString)
+      );
+    } catch {
+    }
+    queryParams = {
+      ...queryParams,
+      ...paramsFromHostUri
+    };
+  }
+  queryString = new URLSearchParams(
+    // For legacy purposes, we'll strip out the nullish values before creating the URL.
+    Object.fromEntries(Object.entries(queryParams).filter(([, value]) => value != null))
+  ).toString();
+  if (queryString) {
+    queryString = `?${queryString}`;
+  }
+  hostUri = ensureLeadingSlash(hostUri, !isTripleSlashed);
+  const encodedURI = encodeURI(`${resolvedScheme}:${isTripleSlashed ? "/" : ""}/${hostUri}${path}`);
+  return `${encodedURI}${queryString}`;
+}
+function parse(url) {
+  validateURL(url);
+  const queryParams = {};
+  let path = null;
+  let hostname = null;
+  let scheme = null;
+  try {
+    const parsed = new URL(url);
+    parsed.searchParams.forEach((value, key) => {
+      queryParams[key] = decodeURIComponent(value);
+    });
+    path = parsed.pathname || null;
+    hostname = parsed.hostname || null;
+    scheme = parsed.protocol || null;
+  } catch {
+    path = url;
+  }
+  const hostUri = getHostUri() || "";
+  const hostUriStripped = removePort(removeTrailingSlashAndQueryString(hostUri));
+  if (scheme) {
+    scheme = scheme.substring(0, scheme.length - 1);
+  }
+  if (path) {
+    path = removeLeadingSlash(path);
+    let expoPrefix = null;
+    if (hostUriStripped) {
+      const parts = hostUriStripped.split("/");
+      expoPrefix = parts.slice(1).concat(["--/"]).join("/");
+    }
+    if (isExpoHosted() && !hasCustomScheme() && expoPrefix && path.startsWith(expoPrefix)) {
+      path = path.substring(expoPrefix.length);
+      hostname = null;
+    } else if (path.indexOf("+") > -1) {
+      path = path.substring(path.indexOf("+") + 1);
+    }
+  }
+  return {
+    hostname,
+    path,
+    queryParams,
+    scheme
+  };
+}
+var init_createURL = __esm({
+  "../node_modules/expo-linking/build/createURL.js"() {
+    "use strict";
+    init_Constants();
+    init_Schemes();
+    init_validateURL();
+  }
+});
+
+// ../node_modules/expo-linking/build/Linking.types.js
+var init_Linking_types = __esm({
+  "../node_modules/expo-linking/build/Linking.types.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/expo-linking/build/Linking.js
+var Linking_exports = {};
+__export(Linking_exports, {
+  addEventListener: () => addEventListener,
+  canOpenURL: () => canOpenURL,
+  collectManifestSchemes: () => collectManifestSchemes,
+  createURL: () => createURL,
+  getInitialURL: () => getInitialURL,
+  getLinkingURL: () => getLinkingURL,
+  hasConstantsManifest: () => hasConstantsManifest,
+  hasCustomScheme: () => hasCustomScheme,
+  openSettings: () => openSettings,
+  openURL: () => openURL,
+  parse: () => parse,
+  parseInitialURLAsync: () => parseInitialURLAsync,
+  resolveScheme: () => resolveScheme,
+  sendIntent: () => sendIntent,
+  useLinkingURL: () => useLinkingURL,
+  useURL: () => useURL
+});
+function addEventListener(type, handler) {
+  return RNLinking_default.addEventListener(type, handler);
+}
+async function parseInitialURLAsync() {
+  const initialUrl = await RNLinking_default.getInitialURL();
+  if (!initialUrl) {
+    return {
+      scheme: null,
+      hostname: null,
+      path: null,
+      queryParams: null
+    };
+  }
+  return parse(initialUrl);
+}
+async function sendIntent(action, extras) {
+  if (import_react_native5.Platform.OS === "android") {
+    return await RNLinking_default.sendIntent(action, extras);
+  }
+  throw new UnavailabilityError("Linking", "sendIntent");
+}
+async function openSettings() {
+  if (import_react_native5.Platform.OS === "web") {
+    throw new UnavailabilityError("Linking", "openSettings");
+  }
+  if (RNLinking_default.openSettings) {
+    return await RNLinking_default.openSettings();
+  }
+  await openURL("app-settings:");
+}
+async function getInitialURL() {
+  return await RNLinking_default.getInitialURL() ?? null;
+}
+function getLinkingURL() {
+  return ExpoLinking_default.getLinkingURL();
+}
+async function openURL(url) {
+  validateURL(url);
+  return await RNLinking_default.openURL(url);
+}
+async function canOpenURL(url) {
+  validateURL(url);
+  return await RNLinking_default.canOpenURL(url);
+}
+function useURL() {
+  const [url, setLink] = (0, import_react4.useState)(null);
+  function onChange(event) {
+    setLink(event.url);
+  }
+  (0, import_react4.useEffect)(() => {
+    getInitialURL().then((url2) => setLink(url2));
+    const subscription = addEventListener("url", onChange);
+    return () => subscription.remove();
+  }, []);
+  return url;
+}
+function useLinkingURL() {
+  const [url, setLink] = (0, import_react4.useState)(ExpoLinking_default.getLinkingURL);
+  function onChange(event) {
+    setLink(event.url);
+  }
+  (0, import_react4.useEffect)(() => {
+    const subscription = ExpoLinking_default.addListener("onURLReceived", onChange);
+    return () => subscription.remove();
+  }, []);
+  return url ?? null;
+}
+var import_react4, import_react_native5;
+var init_Linking = __esm({
+  "../node_modules/expo-linking/build/Linking.js"() {
+    "use strict";
+    init_src();
+    import_react4 = require("react");
+    import_react_native5 = require("react-native");
+    init_ExpoLinking();
+    init_RNLinking();
+    init_createURL();
+    init_validateURL();
+    init_Linking_types();
+    init_Schemes();
+    init_createURL();
+  }
+});
+
+// src/assets/Column.png
+var require_Column = __commonJS({
+  "src/assets/Column.png"(exports2, module2) {
+    module2.exports = "./Column-LINBKAMV.png";
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   ColumnCrypto: () => ColumnCrypto,
+  ColumnWalletModal: () => ColumnWalletModal,
+  ColumnWalletNative: () => ColumnWalletNative,
   ColumnWalletSDK: () => ColumnWalletSDK,
   ColumnWalletWeb: () => ColumnWalletWeb
 });
@@ -482,9 +1445,165 @@ var ColumnWalletWeb = class _ColumnWalletWeb extends ColumnWalletSDK {
     this.modal.open();
   }
 };
+
+// src/ui/native/ColumnWalletNative.ts
+var ColumnWalletNative = class _ColumnWalletNative extends ColumnWalletSDK {
+  constructor(config) {
+    const detectedConfig = _ColumnWalletNative.autoDetectMetadata(config);
+    super(detectedConfig);
+  }
+  static autoDetectMetadata(config) {
+    const detectedConfig = { ...config };
+    try {
+      const Constants = (init_Constants(), __toCommonJS(Constants_exports)).default;
+      const expoConfig = Constants.expoConfig || Constants.manifest;
+      if (!detectedConfig.appName && expoConfig?.name) {
+        detectedConfig.appName = expoConfig.name;
+      }
+      if (!detectedConfig.appDescription && expoConfig?.description) {
+        detectedConfig.appDescription = expoConfig.description;
+      }
+    } catch (e) {
+    }
+    try {
+      if (!detectedConfig.redirectLink) {
+        const Linking3 = (init_Linking(), __toCommonJS(Linking_exports));
+        detectedConfig.redirectLink = Linking3.createURL("");
+      }
+    } catch (e) {
+    }
+    return detectedConfig;
+  }
+};
+
+// src/ui/native/ColumnWalletModal.tsx
+var import_react5 = __toESM(require("react"));
+var import_react_native6 = require("react-native");
+function ColumnWalletModal({ visible, onClose, onConnect, sdk }) {
+  const handleConnect = async () => {
+    try {
+      const url = sdk.connect();
+      console.log("\u{1F517} Modal: Attempting to connect with URL:", url);
+      try {
+        const supported = await import_react_native6.Linking.canOpenURL(url);
+        if (supported) {
+          await import_react_native6.Linking.openURL(url);
+          onConnect();
+          onClose();
+          return;
+        }
+      } catch (e) {
+      }
+      await import_react_native6.Linking.openURL(url).catch(() => {
+      });
+      onConnect();
+      onClose();
+    } catch (error) {
+      console.error("Deep link error:", error);
+    }
+  };
+  return /* @__PURE__ */ import_react5.default.createElement(
+    import_react_native6.Modal,
+    {
+      animationType: "slide",
+      transparent: true,
+      visible,
+      onRequestClose: onClose
+    },
+    /* @__PURE__ */ import_react5.default.createElement(import_react_native6.View, { style: styles.centeredView }, /* @__PURE__ */ import_react5.default.createElement(import_react_native6.TouchableOpacity, { style: styles.overlay, onPress: onClose, activeOpacity: 1 }), /* @__PURE__ */ import_react5.default.createElement(import_react_native6.View, { style: styles.modalView }, /* @__PURE__ */ import_react5.default.createElement(import_react_native6.Text, { style: styles.modalTitle }, "Connect Wallet"), /* @__PURE__ */ import_react5.default.createElement(import_react_native6.TouchableOpacity, { style: styles.walletOption, onPress: handleConnect }, /* @__PURE__ */ import_react5.default.createElement(import_react_native6.View, { style: styles.walletIconContainer }, /* @__PURE__ */ import_react5.default.createElement(
+      import_react_native6.Image,
+      {
+        source: require_Column(),
+        style: styles.walletIconImage
+      }
+    )), /* @__PURE__ */ import_react5.default.createElement(import_react_native6.View, { style: styles.walletInfo }, /* @__PURE__ */ import_react5.default.createElement(import_react_native6.Text, { style: styles.walletName }, "Column Wallet"), /* @__PURE__ */ import_react5.default.createElement(import_react_native6.Text, { style: styles.walletTag }, "Recommended"))), /* @__PURE__ */ import_react5.default.createElement(import_react_native6.TouchableOpacity, { style: styles.closeButton, onPress: onClose }, /* @__PURE__ */ import_react5.default.createElement(import_react_native6.Text, { style: styles.closeButtonText }, "Cancel"))))
+  );
+}
+var styles = import_react_native6.StyleSheet.create({
+  centeredView: {
+    flex: 1,
+    justifyContent: "flex-end",
+    alignItems: "center"
+  },
+  overlay: {
+    ...import_react_native6.StyleSheet.absoluteFillObject,
+    // Setting background to transparent as requested
+    backgroundColor: "transparent"
+  },
+  modalView: {
+    width: "100%",
+    backgroundColor: "#1C1F2E",
+    borderTopLeftRadius: 20,
+    borderTopRightRadius: 20,
+    padding: 24,
+    paddingBottom: 40,
+    shadowColor: "#000",
+    shadowOffset: {
+      width: 0,
+      height: -2
+    },
+    shadowOpacity: 0.25,
+    shadowRadius: 4,
+    elevation: 5
+  },
+  modalTitle: {
+    fontSize: 20,
+    fontWeight: "600",
+    color: "white",
+    marginBottom: 20,
+    textAlign: "center"
+  },
+  walletOption: {
+    flexDirection: "row",
+    alignItems: "center",
+    backgroundColor: "#252938",
+    padding: 16,
+    borderRadius: 16,
+    marginBottom: 16,
+    borderWidth: 1,
+    borderColor: "rgba(255,255,255,0.1)"
+  },
+  walletIconContainer: {
+    width: 40,
+    height: 40,
+    borderRadius: 10,
+    backgroundColor: "#ffda34",
+    justifyContent: "center",
+    alignItems: "center",
+    marginRight: 16
+  },
+  walletIconImage: {
+    width: 24,
+    height: 24,
+    resizeMode: "contain"
+  },
+  walletInfo: {
+    flex: 1
+  },
+  walletName: {
+    color: "white",
+    fontSize: 16,
+    fontWeight: "600"
+  },
+  walletTag: {
+    color: "#8B98A5",
+    fontSize: 12
+  },
+  closeButton: {
+    marginTop: 8,
+    alignItems: "center",
+    padding: 12
+  },
+  closeButtonText: {
+    color: "#8B98A5",
+    fontSize: 16
+  }
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ColumnCrypto,
+  ColumnWalletModal,
+  ColumnWalletNative,
   ColumnWalletSDK,
   ColumnWalletWeb
 });