@injectivelabs/wallet-magic 1.16.36 → 1.16.38-alpha.0

package/dist/cjs/index.cjs

@@ -0,0 +1,201 @@
+let magic_sdk = require("magic-sdk");
+let __magic_ext_oauth2 = require("@magic-ext/oauth2");
+let __magic_ext_cosmos = require("@magic-ext/cosmos");
+let __injectivelabs_sdk_ts = require("@injectivelabs/sdk-ts");
+let __injectivelabs_wallet_base = require("@injectivelabs/wallet-base");
+let __injectivelabs_exceptions = require("@injectivelabs/exceptions");
+
+//#region \0@oxc-project+runtime@0.98.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/strategy/strategy.ts
+var Magic = class extends __injectivelabs_wallet_base.BaseConcreteStrategy {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "provider", void 0);
+		_defineProperty(this, "magicWallet", void 0);
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(__injectivelabs_wallet_base.WalletDeviceType.Browser);
+	}
+	async enable({ email, provider }) {
+		if (!provider) return Promise.resolve(true);
+		try {
+			if (provider === __injectivelabs_wallet_base.MagicProvider.Email) await this.connectViaEmail(email);
+			else await this.connectViaOauth(provider);
+			await this.pollUserLoggedInState();
+			return Promise.resolve(true);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.WalletException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async connectViaEmail(email) {
+		const magicWallet = await this.getMagicWallet();
+		if (!email) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You have to pass the email for using Magic wallet"));
+		return magicWallet.auth.loginWithMagicLink({ email });
+	}
+	async connectViaOauth(provider) {
+		return (await this.getMagicWallet()).oauth2.loginWithRedirect({
+			provider,
+			redirectURI: window.location.origin
+		});
+	}
+	async disconnect() {
+		const magicWallet = await this.getMagicWallet();
+		if (!await magicWallet.user.isLoggedIn()) return;
+		await magicWallet.user.logout();
+	}
+	async getAddresses({ provider }) {
+		const magicWallet = await this.getMagicWallet();
+		if (!provider) try {
+			await magicWallet.oauth2.getRedirectResult();
+		} catch (_unused) {}
+		try {
+			const { publicAddress } = await magicWallet.user.getInfo();
+			if (!(publicAddress === null || publicAddress === void 0 ? void 0 : publicAddress.startsWith("inj"))) return [await magicWallet.cosmos.changeAddress("inj") || ""];
+			return [publicAddress || ""];
+		} catch (e) {
+			throw new __injectivelabs_exceptions.WalletException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async getSessionOrConfirm(address) {
+		return Promise.resolve(`0x${(0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.stringToUint8Array)(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+	}
+	async sendEvmTransaction(_transaction, _options) {
+		throw new __injectivelabs_exceptions.CosmosWalletException(/* @__PURE__ */ new Error("sendEvmTransaction is not supported. Leap only supports sending cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			context: __injectivelabs_wallet_base.WalletAction.SendEvmTransaction
+		});
+	}
+	async sendTransaction(transaction, options) {
+		const { endpoints, txTimeout } = options;
+		if (!endpoints) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You have to pass endpoints.grpc within the options for using Magic wallet"));
+		const response = await new __injectivelabs_sdk_ts.TxGrpcApi(endpoints.grpc).broadcast(transaction, { txTimeout });
+		if (response.code !== 0) throw new __injectivelabs_exceptions.TransactionException(new Error(response.rawLog), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			contextCode: response.code,
+			contextModule: response.codespace
+		});
+		return response;
+	}
+	async signEip712TypedData(eip712json, _address) {
+		return `0x${await (await this.getMagicWallet()).cosmos.signTypedData(eip712json)}`;
+	}
+	async signCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+		});
+	}
+	async signAminoCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signAminoCosmosTransaction"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+		});
+	}
+	async signArbitrary(_signer, _data) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signArbitrary"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+		});
+	}
+	async getEthereumChainId() {
+		throw new __injectivelabs_exceptions.CosmosWalletException(/* @__PURE__ */ new Error("getEthereumChainId is not supported on Magic wallet"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			context: __injectivelabs_wallet_base.WalletAction.GetChainId
+		});
+	}
+	async getEvmTransactionReceipt(_txHash) {
+		throw new __injectivelabs_exceptions.CosmosWalletException(/* @__PURE__ */ new Error("getEvmTransactionReceipt is not supported on Cosmostation"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			context: __injectivelabs_wallet_base.WalletAction.GetEvmTransactionReceipt
+		});
+	}
+	async getPubKey() {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You can only fetch PubKey from Cosmos native wallets"));
+	}
+	async pollUserLoggedInState(timeout = 60 * 1e3) {
+		const magicWallet = await this.getMagicWallet();
+		const POLL_INTERVAL = 3 * 1e3;
+		for (let i = 0; i <= timeout / POLL_INTERVAL; i += 1) {
+			try {
+				const result = await magicWallet.user.isLoggedIn();
+				if (result) return result;
+			} catch (e) {
+				if (e instanceof __injectivelabs_exceptions.TransactionException) throw e;
+			}
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+		}
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error(`User did not verify sign in - timeout of ${timeout}ms`), {
+			context: "Wallet",
+			contextModule: "Magic-Wallet-pollUserLoggedInState"
+		});
+	}
+	async getMagicWallet() {
+		const { metadata } = this;
+		if (!this.magicWallet) {
+			var _metadata$magic, _metadata$magic2;
+			if (!(metadata === null || metadata === void 0 || (_metadata$magic = metadata.magic) === null || _metadata$magic === void 0 ? void 0 : _metadata$magic.apiKey)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You have to pass the apiKey within metadata to use Magic wallet"));
+			if (!(metadata === null || metadata === void 0 || (_metadata$magic2 = metadata.magic) === null || _metadata$magic2 === void 0 ? void 0 : _metadata$magic2.rpcEndpoint)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You have to pass the rpc url endpoint within metadata to use Magic wallet"));
+			this.magicWallet = new magic_sdk.Magic(metadata.magic.apiKey, { extensions: [new __magic_ext_oauth2.OAuthExtension(), new __magic_ext_cosmos.CosmosExtension({
+				rpcUrl: metadata.magic.rpcEndpoint,
+				chain: "inj"
+			})] });
+		}
+		return this.magicWallet;
+	}
+};
+
+//#endregion
+exports.MagicStrategy = Magic;

package/dist/cjs/index.d.cts

@@ -0,0 +1,50 @@
+import { BaseConcreteStrategy, BrowserEip1993Provider, ConcreteWalletStrategy, MagicProvider, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
+import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts";
+
+//#region src/strategy/strategy.d.ts
+declare class Magic extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+  provider: BrowserEip1993Provider | undefined;
+  private magicWallet;
+  getWalletDeviceType(): Promise<WalletDeviceType>;
+  enable({
+    email,
+    provider
+  }: {
+    email?: string;
+    provider?: MagicProvider;
+  }): Promise<boolean>;
+  connectViaEmail(email?: string): Promise<string | null>;
+  connectViaOauth(provider: MagicProvider): Promise<any>;
+  disconnect(): Promise<void>;
+  getAddresses({
+    provider
+  }: {
+    provider: MagicProvider;
+  }): Promise<string[]>;
+  getSessionOrConfirm(address: AccountAddress): Promise<string>;
+  sendEvmTransaction(_transaction: unknown, _options: {
+    address: AccountAddress;
+    evmChainId: EvmChainId;
+  }): Promise<string>;
+  sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<any>;
+  signEip712TypedData(eip712json: string, _address: AccountAddress): Promise<string>;
+  signCosmosTransaction(_transaction: {
+    txRaw: TxRaw;
+    accountNumber: number;
+    chainId: string;
+    address: string;
+  }): Promise<DirectSignResponse>;
+  signAminoCosmosTransaction(_transaction: {
+    address: string;
+    signDoc: StdSignDoc;
+  }): Promise<AminoSignResponse>;
+  signArbitrary(_signer: AccountAddress, _data: string | Uint8Array): Promise<string>;
+  getEthereumChainId(): Promise<string>;
+  getEvmTransactionReceipt(_txHash: string): Promise<string>;
+  getPubKey(): Promise<string>;
+  private pollUserLoggedInState;
+  private getMagicWallet;
+}
+//#endregion
+export { Magic as MagicStrategy };

package/dist/cjs/package.json

@@ -1,3 +1,3 @@
 {
-    "type": "commonjs"
-}
+  "type": "commonjs"
+}

package/dist/esm/index.d.ts

@@ -1 +1,50 @@
-export { Magic as MagicStrategy } from './strategy/strategy.js';
+import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts";
+import { BaseConcreteStrategy, BrowserEip1993Provider, ConcreteWalletStrategy, MagicProvider, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
+
+//#region src/strategy/strategy.d.ts
+declare class Magic extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+  provider: BrowserEip1993Provider | undefined;
+  private magicWallet;
+  getWalletDeviceType(): Promise<WalletDeviceType>;
+  enable({
+    email,
+    provider
+  }: {
+    email?: string;
+    provider?: MagicProvider;
+  }): Promise<boolean>;
+  connectViaEmail(email?: string): Promise<string | null>;
+  connectViaOauth(provider: MagicProvider): Promise<any>;
+  disconnect(): Promise<void>;
+  getAddresses({
+    provider
+  }: {
+    provider: MagicProvider;
+  }): Promise<string[]>;
+  getSessionOrConfirm(address: AccountAddress): Promise<string>;
+  sendEvmTransaction(_transaction: unknown, _options: {
+    address: AccountAddress;
+    evmChainId: EvmChainId;
+  }): Promise<string>;
+  sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<any>;
+  signEip712TypedData(eip712json: string, _address: AccountAddress): Promise<string>;
+  signCosmosTransaction(_transaction: {
+    txRaw: TxRaw;
+    accountNumber: number;
+    chainId: string;
+    address: string;
+  }): Promise<DirectSignResponse>;
+  signAminoCosmosTransaction(_transaction: {
+    address: string;
+    signDoc: StdSignDoc;
+  }): Promise<AminoSignResponse>;
+  signArbitrary(_signer: AccountAddress, _data: string | Uint8Array): Promise<string>;
+  getEthereumChainId(): Promise<string>;
+  getEvmTransactionReceipt(_txHash: string): Promise<string>;
+  getPubKey(): Promise<string>;
+  private pollUserLoggedInState;
+  private getMagicWallet;
+}
+//#endregion
+export { Magic as MagicStrategy };

package/dist/esm/index.js

@@ -1 +1,201 @@
-export { Magic as MagicStrategy } from './strategy/strategy.js';
+import { Magic as Magic$1 } from "magic-sdk";
+import { OAuthExtension } from "@magic-ext/oauth2";
+import { CosmosExtension } from "@magic-ext/cosmos";
+import { TxGrpcApi, stringToUint8Array, uint8ArrayToHex } from "@injectivelabs/sdk-ts";
+import { BaseConcreteStrategy, MagicProvider, WalletAction, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { CosmosWalletException, ErrorType, TransactionException, UnspecifiedErrorCode, WalletException } from "@injectivelabs/exceptions";
+
+//#region \0@oxc-project+runtime@0.98.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/strategy/strategy.ts
+var Magic = class extends BaseConcreteStrategy {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "provider", void 0);
+		_defineProperty(this, "magicWallet", void 0);
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(WalletDeviceType.Browser);
+	}
+	async enable({ email, provider }) {
+		if (!provider) return Promise.resolve(true);
+		try {
+			if (provider === MagicProvider.Email) await this.connectViaEmail(email);
+			else await this.connectViaOauth(provider);
+			await this.pollUserLoggedInState();
+			return Promise.resolve(true);
+		} catch (e) {
+			throw new WalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.GetAccounts
+			});
+		}
+	}
+	async connectViaEmail(email) {
+		const magicWallet = await this.getMagicWallet();
+		if (!email) throw new WalletException(/* @__PURE__ */ new Error("You have to pass the email for using Magic wallet"));
+		return magicWallet.auth.loginWithMagicLink({ email });
+	}
+	async connectViaOauth(provider) {
+		return (await this.getMagicWallet()).oauth2.loginWithRedirect({
+			provider,
+			redirectURI: window.location.origin
+		});
+	}
+	async disconnect() {
+		const magicWallet = await this.getMagicWallet();
+		if (!await magicWallet.user.isLoggedIn()) return;
+		await magicWallet.user.logout();
+	}
+	async getAddresses({ provider }) {
+		const magicWallet = await this.getMagicWallet();
+		if (!provider) try {
+			await magicWallet.oauth2.getRedirectResult();
+		} catch (_unused) {}
+		try {
+			const { publicAddress } = await magicWallet.user.getInfo();
+			if (!(publicAddress === null || publicAddress === void 0 ? void 0 : publicAddress.startsWith("inj"))) return [await magicWallet.cosmos.changeAddress("inj") || ""];
+			return [publicAddress || ""];
+		} catch (e) {
+			throw new WalletException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.GetAccounts
+			});
+		}
+	}
+	async getSessionOrConfirm(address) {
+		return Promise.resolve(`0x${uint8ArrayToHex(stringToUint8Array(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+	}
+	async sendEvmTransaction(_transaction, _options) {
+		throw new CosmosWalletException(/* @__PURE__ */ new Error("sendEvmTransaction is not supported. Leap only supports sending cosmos transactions"), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.SendEvmTransaction
+		});
+	}
+	async sendTransaction(transaction, options) {
+		const { endpoints, txTimeout } = options;
+		if (!endpoints) throw new WalletException(/* @__PURE__ */ new Error("You have to pass endpoints.grpc within the options for using Magic wallet"));
+		const response = await new TxGrpcApi(endpoints.grpc).broadcast(transaction, { txTimeout });
+		if (response.code !== 0) throw new TransactionException(new Error(response.rawLog), {
+			code: UnspecifiedErrorCode,
+			contextCode: response.code,
+			contextModule: response.codespace
+		});
+		return response;
+	}
+	async signEip712TypedData(eip712json, _address) {
+		return `0x${await (await this.getMagicWallet()).cosmos.signTypedData(eip712json)}`;
+	}
+	async signCosmosTransaction(_transaction) {
+		throw new WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignTransaction
+		});
+	}
+	async signAminoCosmosTransaction(_transaction) {
+		throw new WalletException(/* @__PURE__ */ new Error("This wallet does not support signAminoCosmosTransaction"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignTransaction
+		});
+	}
+	async signArbitrary(_signer, _data) {
+		throw new WalletException(/* @__PURE__ */ new Error("This wallet does not support signArbitrary"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignTransaction
+		});
+	}
+	async getEthereumChainId() {
+		throw new CosmosWalletException(/* @__PURE__ */ new Error("getEthereumChainId is not supported on Magic wallet"), {
+			code: UnspecifiedErrorCode,
+			context: WalletAction.GetChainId
+		});
+	}
+	async getEvmTransactionReceipt(_txHash) {
+		throw new CosmosWalletException(/* @__PURE__ */ new Error("getEvmTransactionReceipt is not supported on Cosmostation"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			context: WalletAction.GetEvmTransactionReceipt
+		});
+	}
+	async getPubKey() {
+		throw new WalletException(/* @__PURE__ */ new Error("You can only fetch PubKey from Cosmos native wallets"));
+	}
+	async pollUserLoggedInState(timeout = 60 * 1e3) {
+		const magicWallet = await this.getMagicWallet();
+		const POLL_INTERVAL = 3 * 1e3;
+		for (let i = 0; i <= timeout / POLL_INTERVAL; i += 1) {
+			try {
+				const result = await magicWallet.user.isLoggedIn();
+				if (result) return result;
+			} catch (e) {
+				if (e instanceof TransactionException) throw e;
+			}
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+		}
+		throw new WalletException(/* @__PURE__ */ new Error(`User did not verify sign in - timeout of ${timeout}ms`), {
+			context: "Wallet",
+			contextModule: "Magic-Wallet-pollUserLoggedInState"
+		});
+	}
+	async getMagicWallet() {
+		const { metadata } = this;
+		if (!this.magicWallet) {
+			var _metadata$magic, _metadata$magic2;
+			if (!(metadata === null || metadata === void 0 || (_metadata$magic = metadata.magic) === null || _metadata$magic === void 0 ? void 0 : _metadata$magic.apiKey)) throw new WalletException(/* @__PURE__ */ new Error("You have to pass the apiKey within metadata to use Magic wallet"));
+			if (!(metadata === null || metadata === void 0 || (_metadata$magic2 = metadata.magic) === null || _metadata$magic2 === void 0 ? void 0 : _metadata$magic2.rpcEndpoint)) throw new WalletException(/* @__PURE__ */ new Error("You have to pass the rpc url endpoint within metadata to use Magic wallet"));
+			this.magicWallet = new Magic$1(metadata.magic.apiKey, { extensions: [new OAuthExtension(), new CosmosExtension({
+				rpcUrl: metadata.magic.rpcEndpoint,
+				chain: "inj"
+			})] });
+		}
+		return this.magicWallet;
+	}
+};
+
+//#endregion
+export { Magic as MagicStrategy };

package/dist/esm/package.json

@@ -1,3 +1,3 @@
 {
-    "type": "module"
-}
+  "type": "module"
+}

package/package.json

@@ -1,23 +1,14 @@
 {
   "name": "@injectivelabs/wallet-magic",
+  "version": "1.16.38-alpha.0",
   "description": "Magic wallet strategy for use with @injectivelabs/wallet-core.",
-  "version": "1.16.36",
-  "sideEffects": false,
-  "type": "module",
+  "license": "Apache-2.0",
   "author": {
     "name": "InjectiveLabs",
     "email": "admin@injectivelabs.org"
   },
-  "license": "Apache-2.0",
-  "types": "dist/cjs/index.d.ts",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "files": [
-    "dist"
-  ],
-  "_moduleAliases": {
-    "~wallet-magic": "dist"
-  },
+  "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "react-native": {
@@ -40,38 +31,42 @@
       }
     }
   },
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "pnpm build:cjs && pnpm build:esm && pnpm build:post",
-    "build:cjs": "tsc --build --force tsconfig.build.json",
-    "build:esm": "tsc --build --force tsconfig.build.esm.json",
-    "build:watch": "tsc --build -w tsconfig.build.json && tsc -w --build tsconfig.build.esm.json && pnpm build:post",
-    "build:post": "shx cp ../../../etc/stub/package.json.stub dist/cjs/package.json && shx cp ../../../etc/stub/package.esm.json.stub dist/esm/package.json",
-    "clean": "tsc --build tsconfig.build.json --clean && tsc --build tsconfig.build.esm.json --clean && shx rm -rf coverage *.log junit.xml dist && jest --clearCache && shx mkdir -p dist",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:ci": "jest --coverage --ci --reporters='jest-junit'",
-    "coverage": "jest --coverage",
+    "build": "pnpm type-check && tsdown",
+    "build:fast": "tsdown",
+    "build:watch": "tsdown --watch",
+    "clean": "shx rm -rf dist coverage *.log junit.xml && shx mkdir -p dist",
+    "type-check": "tsc --noEmit",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:ci": "vitest run --coverage --reporter=verbose",
+    "coverage": "vitest run --coverage",
     "coverage:show": "live-server coverage",
     "dev": "ts-node -r tsconfig-paths/register src/index.ts",
-    "start": "node dist/index.js"
+    "start": "node dist/index.js",
+    "lint": "eslint . --ext .ts,.js"
   },
   "dependencies": {
-    "@injectivelabs/exceptions": "1.16.36",
-    "@injectivelabs/sdk-ts": "1.16.36",
-    "@injectivelabs/ts-types": "1.16.36",
-    "@injectivelabs/utils": "1.16.36",
-    "@injectivelabs/wallet-base": "1.16.36",
+    "@injectivelabs/exceptions": "1.16.38-alpha.0",
+    "@injectivelabs/sdk-ts": "1.16.38-alpha.0",
+    "@injectivelabs/ts-types": "1.16.38-alpha.0",
+    "@injectivelabs/utils": "1.16.38-alpha.0",
+    "@injectivelabs/wallet-base": "1.16.38-alpha.0",
     "@magic-ext/cosmos": "23.9.1",
     "@magic-ext/oauth2": "9.9.0",
     "magic-sdk": "29.1.0"
   },
-  "devDependencies": {
-    "shx": "^0.3.4"
+  "publishConfig": {
+    "access": "public"
+  },
+  "_moduleAliases": {
+    "~wallet-magic": "dist"
   },
-  "gitHead": "276eeece6aa5734e6fe7df1bd0601ee968ca018b",
-  "typedoc": {
-    "entryPoint": "./src/index.ts",
-    "readmeFile": "./README.md",
-    "displayName": "wallet-magic API Documentation"
-  }
+  "gitHead": "35da21add71ed443fad349d811cf9458043baee7"
 }

package/dist/cjs/index.d.ts

@@ -1 +0,0 @@
-export { Magic as MagicStrategy } from './strategy/strategy.js';

package/dist/cjs/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MagicStrategy = void 0;
-var strategy_js_1 = require("./strategy/strategy.js");
-Object.defineProperty(exports, "MagicStrategy", { enumerable: true, get: function () { return strategy_js_1.Magic; } });

package/dist/cjs/strategy/strategy.d.ts

@@ -1,42 +0,0 @@
-import { MagicProvider, WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
-import type { AccountAddress, EvmChainId } from '@injectivelabs/ts-types';
-import type { TxRaw, DirectSignResponse, AminoSignResponse } from '@injectivelabs/sdk-ts';
-import type { StdSignDoc, BrowserEip1993Provider, ConcreteWalletStrategy, SendTransactionOptions } from '@injectivelabs/wallet-base';
-export declare class Magic extends BaseConcreteStrategy implements ConcreteWalletStrategy {
-    provider: BrowserEip1993Provider | undefined;
-    private magicWallet;
-    getWalletDeviceType(): Promise<WalletDeviceType>;
-    enable({ email, provider, }: {
-        email?: string;
-        provider?: MagicProvider;
-    }): Promise<boolean>;
-    connectViaEmail(email?: string): Promise<string | null>;
-    connectViaOauth(provider: MagicProvider): Promise<any>;
-    disconnect(): Promise<void>;
-    getAddresses({ provider, }: {
-        provider: MagicProvider;
-    }): Promise<string[]>;
-    getSessionOrConfirm(address: AccountAddress): Promise<string>;
-    sendEvmTransaction(_transaction: unknown, _options: {
-        address: AccountAddress;
-        evmChainId: EvmChainId;
-    }): Promise<string>;
-    sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<any>;
-    signEip712TypedData(eip712json: string, _address: AccountAddress): Promise<string>;
-    signCosmosTransaction(_transaction: {
-        txRaw: TxRaw;
-        accountNumber: number;
-        chainId: string;
-        address: string;
-    }): Promise<DirectSignResponse>;
-    signAminoCosmosTransaction(_transaction: {
-        address: string;
-        signDoc: StdSignDoc;
-    }): Promise<AminoSignResponse>;
-    signArbitrary(_signer: AccountAddress, _data: string | Uint8Array): Promise<string>;
-    getEthereumChainId(): Promise<string>;
-    getEvmTransactionReceipt(_txHash: string): Promise<string>;
-    getPubKey(): Promise<string>;
-    private pollUserLoggedInState;
-    private getMagicWallet;
-}

package/dist/cjs/strategy/strategy.js

@@ -1,199 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Magic = void 0;
-const magic_sdk_1 = require("magic-sdk");
-const sdk_ts_1 = require("@injectivelabs/sdk-ts");
-const oauth2_1 = require("@magic-ext/oauth2");
-const cosmos_1 = require("@magic-ext/cosmos");
-const wallet_base_1 = require("@injectivelabs/wallet-base");
-const exceptions_1 = require("@injectivelabs/exceptions");
-class Magic extends wallet_base_1.BaseConcreteStrategy {
-    provider;
-    magicWallet;
-    async getWalletDeviceType() {
-        return Promise.resolve(wallet_base_1.WalletDeviceType.Browser);
-    }
-    async enable({ email, provider, }) {
-        if (!provider) {
-            return Promise.resolve(true);
-        }
-        try {
-            if (provider === wallet_base_1.MagicProvider.Email) {
-                await this.connectViaEmail(email);
-            }
-            else {
-                await this.connectViaOauth(provider);
-            }
-            await this.pollUserLoggedInState();
-            return Promise.resolve(true);
-        }
-        catch (e) {
-            throw new exceptions_1.WalletException(new Error(e.message), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                type: exceptions_1.ErrorType.WalletError,
-                contextModule: wallet_base_1.WalletAction.GetAccounts,
-            });
-        }
-    }
-    async connectViaEmail(email) {
-        const magicWallet = await this.getMagicWallet();
-        if (!email) {
-            throw new exceptions_1.WalletException(new Error('You have to pass the email for using Magic wallet'));
-        }
-        return magicWallet.auth.loginWithMagicLink({ email });
-    }
-    async connectViaOauth(provider) {
-        const magicWallet = await this.getMagicWallet();
-        return magicWallet.oauth2.loginWithRedirect({
-            provider: provider,
-            redirectURI: window.location.origin,
-        });
-    }
-    async disconnect() {
-        const magicWallet = await this.getMagicWallet();
-        const isUserLoggedIn = await magicWallet.user.isLoggedIn();
-        if (!isUserLoggedIn) {
-            return;
-        }
-        await magicWallet.user.logout();
-    }
-    async getAddresses({ provider, }) {
-        const magicWallet = await this.getMagicWallet();
-        if (!provider) {
-            try {
-                await magicWallet.oauth2.getRedirectResult();
-            }
-            catch {
-                // fail silently
-            }
-        }
-        try {
-            const { publicAddress } = await magicWallet.user.getInfo();
-            if (!publicAddress?.startsWith('inj')) {
-                const address = await magicWallet.cosmos.changeAddress('inj');
-                return [address || ''];
-            }
-            return [publicAddress || ''];
-        }
-        catch (e) {
-            throw new exceptions_1.WalletException(new Error(e.message), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                type: exceptions_1.ErrorType.WalletError,
-                contextModule: wallet_base_1.WalletAction.GetAccounts,
-            });
-        }
-    }
-    async getSessionOrConfirm(address) {
-        return Promise.resolve(`0x${Buffer.from(`Confirmation for ${address} at time: ${Date.now()}`).toString('hex')}`);
-    }
-    async sendEvmTransaction(_transaction, _options) {
-        throw new exceptions_1.CosmosWalletException(new Error('sendEvmTransaction is not supported. Leap only supports sending cosmos transactions'), {
-            code: exceptions_1.UnspecifiedErrorCode,
-            context: wallet_base_1.WalletAction.SendEvmTransaction,
-        });
-    }
-    async sendTransaction(transaction, options) {
-        const { endpoints, txTimeout } = options;
-        if (!endpoints) {
-            throw new exceptions_1.WalletException(new Error('You have to pass endpoints.grpc within the options for using Magic wallet'));
-        }
-        const txApi = new sdk_ts_1.TxGrpcApi(endpoints.grpc);
-        const response = await txApi.broadcast(transaction, { txTimeout });
-        if (response.code !== 0) {
-            throw new exceptions_1.TransactionException(new Error(response.rawLog), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                contextCode: response.code,
-                contextModule: response.codespace,
-            });
-        }
-        return response;
-    }
-    async signEip712TypedData(eip712json, _address) {
-        const magicWallet = await this.getMagicWallet();
-        const signature = await magicWallet.cosmos.signTypedData(eip712json);
-        return `0x${signature}`;
-    }
-    async signCosmosTransaction(_transaction) {
-        throw new exceptions_1.WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
-            code: exceptions_1.UnspecifiedErrorCode,
-            type: exceptions_1.ErrorType.WalletError,
-            contextModule: wallet_base_1.WalletAction.SignTransaction,
-        });
-    }
-    async signAminoCosmosTransaction(_transaction) {
-        throw new exceptions_1.WalletException(new Error('This wallet does not support signAminoCosmosTransaction'), {
-            code: exceptions_1.UnspecifiedErrorCode,
-            type: exceptions_1.ErrorType.WalletError,
-            contextModule: wallet_base_1.WalletAction.SignTransaction,
-        });
-    }
-    async signArbitrary(_signer, _data) {
-        throw new exceptions_1.WalletException(new Error('This wallet does not support signArbitrary'), {
-            code: exceptions_1.UnspecifiedErrorCode,
-            type: exceptions_1.ErrorType.WalletError,
-            contextModule: wallet_base_1.WalletAction.SignTransaction,
-        });
-    }
-    async getEthereumChainId() {
-        throw new exceptions_1.CosmosWalletException(new Error('getEthereumChainId is not supported on Magic wallet'), {
-            code: exceptions_1.UnspecifiedErrorCode,
-            context: wallet_base_1.WalletAction.GetChainId,
-        });
-    }
-    async getEvmTransactionReceipt(_txHash) {
-        throw new exceptions_1.CosmosWalletException(new Error('getEvmTransactionReceipt is not supported on Cosmostation'), {
-            code: exceptions_1.UnspecifiedErrorCode,
-            type: exceptions_1.ErrorType.WalletError,
-            context: wallet_base_1.WalletAction.GetEvmTransactionReceipt,
-        });
-    }
-    async getPubKey() {
-        throw new exceptions_1.WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
-    }
-    async pollUserLoggedInState(timeout = 60 * 1000) {
-        const magicWallet = await this.getMagicWallet();
-        const POLL_INTERVAL = 3 * 1000;
-        for (let i = 0; i <= timeout / POLL_INTERVAL; i += 1) {
-            try {
-                const result = await magicWallet.user.isLoggedIn();
-                if (result) {
-                    return result;
-                }
-            }
-            catch (e) {
-                // We throw only if the transaction failed on chain
-                if (e instanceof exceptions_1.TransactionException) {
-                    throw e;
-                }
-            }
-            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
-        }
-        // Transaction was not included in the block in the desired timeout
-        throw new exceptions_1.WalletException(new Error(`User did not verify sign in - timeout of ${timeout}ms`), {
-            context: 'Wallet',
-            contextModule: 'Magic-Wallet-pollUserLoggedInState',
-        });
-    }
-    async getMagicWallet() {
-        const { metadata } = this;
-        if (!this.magicWallet) {
-            if (!metadata?.magic?.apiKey) {
-                throw new exceptions_1.WalletException(new Error('You have to pass the apiKey within metadata to use Magic wallet'));
-            }
-            if (!metadata?.magic?.rpcEndpoint) {
-                throw new exceptions_1.WalletException(new Error('You have to pass the rpc url endpoint within metadata to use Magic wallet'));
-            }
-            this.magicWallet = new magic_sdk_1.Magic(metadata.magic.apiKey, {
-                extensions: [
-                    new oauth2_1.OAuthExtension(),
-                    new cosmos_1.CosmosExtension({
-                        rpcUrl: metadata.magic.rpcEndpoint,
-                        chain: 'inj',
-                    }),
-                ],
-            });
-        }
-        return this.magicWallet;
-    }
-}
-exports.Magic = Magic;

package/dist/esm/strategy/strategy.d.ts

@@ -1,42 +0,0 @@
-import { MagicProvider, WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
-import type { AccountAddress, EvmChainId } from '@injectivelabs/ts-types';
-import type { TxRaw, DirectSignResponse, AminoSignResponse } from '@injectivelabs/sdk-ts';
-import type { StdSignDoc, BrowserEip1993Provider, ConcreteWalletStrategy, SendTransactionOptions } from '@injectivelabs/wallet-base';
-export declare class Magic extends BaseConcreteStrategy implements ConcreteWalletStrategy {
-    provider: BrowserEip1993Provider | undefined;
-    private magicWallet;
-    getWalletDeviceType(): Promise<WalletDeviceType>;
-    enable({ email, provider, }: {
-        email?: string;
-        provider?: MagicProvider;
-    }): Promise<boolean>;
-    connectViaEmail(email?: string): Promise<string | null>;
-    connectViaOauth(provider: MagicProvider): Promise<any>;
-    disconnect(): Promise<void>;
-    getAddresses({ provider, }: {
-        provider: MagicProvider;
-    }): Promise<string[]>;
-    getSessionOrConfirm(address: AccountAddress): Promise<string>;
-    sendEvmTransaction(_transaction: unknown, _options: {
-        address: AccountAddress;
-        evmChainId: EvmChainId;
-    }): Promise<string>;
-    sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<any>;
-    signEip712TypedData(eip712json: string, _address: AccountAddress): Promise<string>;
-    signCosmosTransaction(_transaction: {
-        txRaw: TxRaw;
-        accountNumber: number;
-        chainId: string;
-        address: string;
-    }): Promise<DirectSignResponse>;
-    signAminoCosmosTransaction(_transaction: {
-        address: string;
-        signDoc: StdSignDoc;
-    }): Promise<AminoSignResponse>;
-    signArbitrary(_signer: AccountAddress, _data: string | Uint8Array): Promise<string>;
-    getEthereumChainId(): Promise<string>;
-    getEvmTransactionReceipt(_txHash: string): Promise<string>;
-    getPubKey(): Promise<string>;
-    private pollUserLoggedInState;
-    private getMagicWallet;
-}

package/dist/esm/strategy/strategy.js

@@ -1,195 +0,0 @@
-import { Magic as MagicWallet } from 'magic-sdk';
-import { TxGrpcApi } from '@injectivelabs/sdk-ts';
-import { OAuthExtension } from '@magic-ext/oauth2';
-import { CosmosExtension } from '@magic-ext/cosmos';
-import { WalletAction, MagicProvider, WalletDeviceType, BaseConcreteStrategy, } from '@injectivelabs/wallet-base';
-import { ErrorType, WalletException, UnspecifiedErrorCode, TransactionException, CosmosWalletException, } from '@injectivelabs/exceptions';
-export class Magic extends BaseConcreteStrategy {
-    provider;
-    magicWallet;
-    async getWalletDeviceType() {
-        return Promise.resolve(WalletDeviceType.Browser);
-    }
-    async enable({ email, provider, }) {
-        if (!provider) {
-            return Promise.resolve(true);
-        }
-        try {
-            if (provider === MagicProvider.Email) {
-                await this.connectViaEmail(email);
-            }
-            else {
-                await this.connectViaOauth(provider);
-            }
-            await this.pollUserLoggedInState();
-            return Promise.resolve(true);
-        }
-        catch (e) {
-            throw new WalletException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                type: ErrorType.WalletError,
-                contextModule: WalletAction.GetAccounts,
-            });
-        }
-    }
-    async connectViaEmail(email) {
-        const magicWallet = await this.getMagicWallet();
-        if (!email) {
-            throw new WalletException(new Error('You have to pass the email for using Magic wallet'));
-        }
-        return magicWallet.auth.loginWithMagicLink({ email });
-    }
-    async connectViaOauth(provider) {
-        const magicWallet = await this.getMagicWallet();
-        return magicWallet.oauth2.loginWithRedirect({
-            provider: provider,
-            redirectURI: window.location.origin,
-        });
-    }
-    async disconnect() {
-        const magicWallet = await this.getMagicWallet();
-        const isUserLoggedIn = await magicWallet.user.isLoggedIn();
-        if (!isUserLoggedIn) {
-            return;
-        }
-        await magicWallet.user.logout();
-    }
-    async getAddresses({ provider, }) {
-        const magicWallet = await this.getMagicWallet();
-        if (!provider) {
-            try {
-                await magicWallet.oauth2.getRedirectResult();
-            }
-            catch {
-                // fail silently
-            }
-        }
-        try {
-            const { publicAddress } = await magicWallet.user.getInfo();
-            if (!publicAddress?.startsWith('inj')) {
-                const address = await magicWallet.cosmos.changeAddress('inj');
-                return [address || ''];
-            }
-            return [publicAddress || ''];
-        }
-        catch (e) {
-            throw new WalletException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                type: ErrorType.WalletError,
-                contextModule: WalletAction.GetAccounts,
-            });
-        }
-    }
-    async getSessionOrConfirm(address) {
-        return Promise.resolve(`0x${Buffer.from(`Confirmation for ${address} at time: ${Date.now()}`).toString('hex')}`);
-    }
-    async sendEvmTransaction(_transaction, _options) {
-        throw new CosmosWalletException(new Error('sendEvmTransaction is not supported. Leap only supports sending cosmos transactions'), {
-            code: UnspecifiedErrorCode,
-            context: WalletAction.SendEvmTransaction,
-        });
-    }
-    async sendTransaction(transaction, options) {
-        const { endpoints, txTimeout } = options;
-        if (!endpoints) {
-            throw new WalletException(new Error('You have to pass endpoints.grpc within the options for using Magic wallet'));
-        }
-        const txApi = new TxGrpcApi(endpoints.grpc);
-        const response = await txApi.broadcast(transaction, { txTimeout });
-        if (response.code !== 0) {
-            throw new TransactionException(new Error(response.rawLog), {
-                code: UnspecifiedErrorCode,
-                contextCode: response.code,
-                contextModule: response.codespace,
-            });
-        }
-        return response;
-    }
-    async signEip712TypedData(eip712json, _address) {
-        const magicWallet = await this.getMagicWallet();
-        const signature = await magicWallet.cosmos.signTypedData(eip712json);
-        return `0x${signature}`;
-    }
-    async signCosmosTransaction(_transaction) {
-        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
-            code: UnspecifiedErrorCode,
-            type: ErrorType.WalletError,
-            contextModule: WalletAction.SignTransaction,
-        });
-    }
-    async signAminoCosmosTransaction(_transaction) {
-        throw new WalletException(new Error('This wallet does not support signAminoCosmosTransaction'), {
-            code: UnspecifiedErrorCode,
-            type: ErrorType.WalletError,
-            contextModule: WalletAction.SignTransaction,
-        });
-    }
-    async signArbitrary(_signer, _data) {
-        throw new WalletException(new Error('This wallet does not support signArbitrary'), {
-            code: UnspecifiedErrorCode,
-            type: ErrorType.WalletError,
-            contextModule: WalletAction.SignTransaction,
-        });
-    }
-    async getEthereumChainId() {
-        throw new CosmosWalletException(new Error('getEthereumChainId is not supported on Magic wallet'), {
-            code: UnspecifiedErrorCode,
-            context: WalletAction.GetChainId,
-        });
-    }
-    async getEvmTransactionReceipt(_txHash) {
-        throw new CosmosWalletException(new Error('getEvmTransactionReceipt is not supported on Cosmostation'), {
-            code: UnspecifiedErrorCode,
-            type: ErrorType.WalletError,
-            context: WalletAction.GetEvmTransactionReceipt,
-        });
-    }
-    async getPubKey() {
-        throw new WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
-    }
-    async pollUserLoggedInState(timeout = 60 * 1000) {
-        const magicWallet = await this.getMagicWallet();
-        const POLL_INTERVAL = 3 * 1000;
-        for (let i = 0; i <= timeout / POLL_INTERVAL; i += 1) {
-            try {
-                const result = await magicWallet.user.isLoggedIn();
-                if (result) {
-                    return result;
-                }
-            }
-            catch (e) {
-                // We throw only if the transaction failed on chain
-                if (e instanceof TransactionException) {
-                    throw e;
-                }
-            }
-            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
-        }
-        // Transaction was not included in the block in the desired timeout
-        throw new WalletException(new Error(`User did not verify sign in - timeout of ${timeout}ms`), {
-            context: 'Wallet',
-            contextModule: 'Magic-Wallet-pollUserLoggedInState',
-        });
-    }
-    async getMagicWallet() {
-        const { metadata } = this;
-        if (!this.magicWallet) {
-            if (!metadata?.magic?.apiKey) {
-                throw new WalletException(new Error('You have to pass the apiKey within metadata to use Magic wallet'));
-            }
-            if (!metadata?.magic?.rpcEndpoint) {
-                throw new WalletException(new Error('You have to pass the rpc url endpoint within metadata to use Magic wallet'));
-            }
-            this.magicWallet = new MagicWallet(metadata.magic.apiKey, {
-                extensions: [
-                    new OAuthExtension(),
-                    new CosmosExtension({
-                        rpcUrl: metadata.magic.rpcEndpoint,
-                        chain: 'inj',
-                    }),
-                ],
-            });
-        }
-        return this.magicWallet;
-    }
-}