@injectivelabs/wallet-private-key 1.16.38 → 1.16.39-alpha.0

package/dist/cjs/index.cjs

@@ -0,0 +1,187 @@
+let __injectivelabs_ts_types = require("@injectivelabs/ts-types");
+let __injectivelabs_sdk_ts_core_accounts = require("@injectivelabs/sdk-ts/core/accounts");
+let __injectivelabs_sdk_ts_core_tx = require("@injectivelabs/sdk-ts/core/tx");
+let __injectivelabs_wallet_base = require("@injectivelabs/wallet-base");
+let __injectivelabs_sdk_ts_utils = require("@injectivelabs/sdk-ts/utils");
+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 PrivateKeyWallet = class extends __injectivelabs_wallet_base.BaseConcreteStrategy {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "privateKey", void 0);
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(__injectivelabs_wallet_base.WalletDeviceType.Other);
+	}
+	async enable() {
+		return Promise.resolve(true);
+	}
+	async disconnect() {
+		this.listeners = {};
+	}
+	async getAddresses() {
+		const pk = this.getPrivateKey();
+		try {
+			return Promise.resolve([pk.toAddress().toHex()]);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.MetamaskException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async getAddressesInfo() {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("getAddressesInfo is not implemented"), {
+			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_utils.uint8ArrayToHex)((0, __injectivelabs_sdk_ts_utils.stringToUint8Array)(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+	}
+	async sendEvmTransaction(_transaction, _options) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support sending Evm transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __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 within the options for using Ethereum native wallets"));
+		const response = await new __injectivelabs_sdk_ts_core_tx.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) {
+		const pk = this.getPrivateKey();
+		if ((0, __injectivelabs_sdk_ts_core_tx.getInjectiveSignerAddress)(address) !== pk.toAddress().toBech32()) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("Signer address does not match the private key address"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+		});
+		try {
+			return `0x${(0, __injectivelabs_sdk_ts_utils.uint8ArrayToHex)(await pk.signTypedData(JSON.parse(eip712json)))}`;
+		} catch (e) {
+			throw new __injectivelabs_exceptions.MetamaskException(new Error(e.message), {
+				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 signing Cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+		});
+	}
+	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 signArbitrary(signer, data) {
+		const pk = this.getPrivateKey();
+		if ((0, __injectivelabs_sdk_ts_core_tx.getInjectiveSignerAddress)(signer) !== pk.toAddress().toBech32()) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("Signer address does not match the private key address"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SignArbitrary
+		});
+		try {
+			return `0x${(0, __injectivelabs_sdk_ts_utils.uint8ArrayToBase64)(await pk.signHashed((0, __injectivelabs_sdk_ts_utils.stringToUint8Array)((0, __injectivelabs_sdk_ts_utils.toUtf8)(data))))}`;
+		} catch (e) {
+			throw new __injectivelabs_exceptions.MetamaskException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignArbitrary
+			});
+		}
+	}
+	async getEthereumChainId() {
+		try {
+			return Promise.resolve((this.chainId === __injectivelabs_ts_types.ChainId.Mainnet ? __injectivelabs_ts_types.EvmChainId.Mainnet : __injectivelabs_ts_types.EvmChainId.Sepolia).toString(16));
+		} catch (e) {
+			throw new __injectivelabs_exceptions.MetamaskException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetChainId
+			});
+		}
+	}
+	async getEvmTransactionReceipt(_txHash) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("Not supported"));
+	}
+	async getPubKey() {
+		return this.getPrivateKey().toPublicKey().toBase64();
+	}
+	async onChainIdChanged(_callback) {}
+	async onAccountChange(_callback) {}
+	getPrivateKey() {
+		if (!this.privateKey) {
+			var _this$metadata;
+			if (!((_this$metadata = this.metadata) === null || _this$metadata === void 0 || (_this$metadata = _this$metadata.privateKey) === null || _this$metadata === void 0 ? void 0 : _this$metadata.privateKey)) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("Please provide private key in the constructor"), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletNotInstalledError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+			this.privateKey = __injectivelabs_sdk_ts_core_accounts.PrivateKey.fromHex(this.metadata.privateKey.privateKey);
+		}
+		return this.privateKey;
+	}
+};
+
+//#endregion
+exports.PrivateKeyWalletStrategy = PrivateKeyWallet;

package/dist/cjs/index.d.cts

@@ -0,0 +1,44 @@
+import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
+import { BaseConcreteStrategy, ConcreteWalletStrategy, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { TxResponse } from "@injectivelabs/sdk-ts/core/tx";
+import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts/types";
+
+//#region src/strategy/strategy.d.ts
+declare class PrivateKeyWallet extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+  private privateKey?;
+  getWalletDeviceType(): Promise<WalletDeviceType>;
+  enable(): Promise<boolean>;
+  disconnect(): Promise<void>;
+  getAddresses(): Promise<string[]>;
+  getAddressesInfo(): Promise<{
+    address: string;
+    derivationPath: string;
+    baseDerivationPath: string;
+  }[]>;
+  getSessionOrConfirm(address: AccountAddress): Promise<string>;
+  sendEvmTransaction(_transaction: unknown, _options: {
+    address: AccountAddress;
+    evmChainId: EvmChainId;
+  }): Promise<string>;
+  sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+  signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
+  signAminoCosmosTransaction(_transaction: {
+    address: string;
+    signDoc: StdSignDoc;
+  }): Promise<AminoSignResponse>;
+  signCosmosTransaction(_transaction: {
+    txRaw: TxRaw;
+    accountNumber: number;
+    chainId: string;
+    address: string;
+  }): Promise<DirectSignResponse>;
+  signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
+  getEthereumChainId(): Promise<string>;
+  getEvmTransactionReceipt(_txHash: string): Promise<string>;
+  getPubKey(): Promise<string>;
+  onChainIdChanged(_callback: (chain: string) => void): Promise<void>;
+  onAccountChange(_callback: (account: AccountAddress | string[]) => void): Promise<void>;
+  private getPrivateKey;
+}
+//#endregion
+export { PrivateKeyWallet as PrivateKeyWalletStrategy };

package/dist/cjs/package.json

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

package/dist/esm/index.d.ts

@@ -1 +1,44 @@
-export { PrivateKeyWallet as PrivateKeyWalletStrategy } from './strategy/strategy.js';
+import { AccountAddress, EvmChainId } from "@injectivelabs/ts-types";
+import { TxResponse } from "@injectivelabs/sdk-ts/core/tx";
+import { BaseConcreteStrategy, ConcreteWalletStrategy, SendTransactionOptions, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { AminoSignResponse, DirectSignResponse, TxRaw } from "@injectivelabs/sdk-ts/types";
+
+//#region src/strategy/strategy.d.ts
+declare class PrivateKeyWallet extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+  private privateKey?;
+  getWalletDeviceType(): Promise<WalletDeviceType>;
+  enable(): Promise<boolean>;
+  disconnect(): Promise<void>;
+  getAddresses(): Promise<string[]>;
+  getAddressesInfo(): Promise<{
+    address: string;
+    derivationPath: string;
+    baseDerivationPath: string;
+  }[]>;
+  getSessionOrConfirm(address: AccountAddress): Promise<string>;
+  sendEvmTransaction(_transaction: unknown, _options: {
+    address: AccountAddress;
+    evmChainId: EvmChainId;
+  }): Promise<string>;
+  sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+  signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
+  signAminoCosmosTransaction(_transaction: {
+    address: string;
+    signDoc: StdSignDoc;
+  }): Promise<AminoSignResponse>;
+  signCosmosTransaction(_transaction: {
+    txRaw: TxRaw;
+    accountNumber: number;
+    chainId: string;
+    address: string;
+  }): Promise<DirectSignResponse>;
+  signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
+  getEthereumChainId(): Promise<string>;
+  getEvmTransactionReceipt(_txHash: string): Promise<string>;
+  getPubKey(): Promise<string>;
+  onChainIdChanged(_callback: (chain: string) => void): Promise<void>;
+  onAccountChange(_callback: (account: AccountAddress | string[]) => void): Promise<void>;
+  private getPrivateKey;
+}
+//#endregion
+export { PrivateKeyWallet as PrivateKeyWalletStrategy };

package/dist/esm/index.js

@@ -1 +1,187 @@
-export { PrivateKeyWallet as PrivateKeyWalletStrategy } from './strategy/strategy.js';
+import { ChainId, EvmChainId } from "@injectivelabs/ts-types";
+import { PrivateKey } from "@injectivelabs/sdk-ts/core/accounts";
+import { TxGrpcApi, getInjectiveSignerAddress } from "@injectivelabs/sdk-ts/core/tx";
+import { BaseConcreteStrategy, WalletAction, WalletDeviceType } from "@injectivelabs/wallet-base";
+import { stringToUint8Array, toUtf8, uint8ArrayToBase64, uint8ArrayToHex } from "@injectivelabs/sdk-ts/utils";
+import { ErrorType, MetamaskException, 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 PrivateKeyWallet = class extends BaseConcreteStrategy {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "privateKey", void 0);
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(WalletDeviceType.Other);
+	}
+	async enable() {
+		return Promise.resolve(true);
+	}
+	async disconnect() {
+		this.listeners = {};
+	}
+	async getAddresses() {
+		const pk = this.getPrivateKey();
+		try {
+			return Promise.resolve([pk.toAddress().toHex()]);
+		} catch (e) {
+			throw new MetamaskException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.GetAccounts
+			});
+		}
+	}
+	async getAddressesInfo() {
+		throw new WalletException(/* @__PURE__ */ new Error("getAddressesInfo is not implemented"), {
+			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 WalletException(/* @__PURE__ */ new Error("This wallet does not support sending Evm transactions"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SendEvmTransaction
+		});
+	}
+	async sendTransaction(transaction, options) {
+		const { endpoints, txTimeout } = options;
+		if (!endpoints) throw new WalletException(/* @__PURE__ */ new Error("You have to pass endpoints within the options for using Ethereum native wallets"));
+		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) {
+		const pk = this.getPrivateKey();
+		if (getInjectiveSignerAddress(address) !== pk.toAddress().toBech32()) throw new WalletException(/* @__PURE__ */ new Error("Signer address does not match the private key address"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignTransaction
+		});
+		try {
+			return `0x${uint8ArrayToHex(await pk.signTypedData(JSON.parse(eip712json)))}`;
+		} catch (e) {
+			throw new MetamaskException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.SignTransaction
+			});
+		}
+	}
+	async signAminoCosmosTransaction(_transaction) {
+		throw new WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignTransaction
+		});
+	}
+	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 signArbitrary(signer, data) {
+		const pk = this.getPrivateKey();
+		if (getInjectiveSignerAddress(signer) !== pk.toAddress().toBech32()) throw new WalletException(/* @__PURE__ */ new Error("Signer address does not match the private key address"), {
+			code: UnspecifiedErrorCode,
+			type: ErrorType.WalletError,
+			contextModule: WalletAction.SignArbitrary
+		});
+		try {
+			return `0x${uint8ArrayToBase64(await pk.signHashed(stringToUint8Array(toUtf8(data))))}`;
+		} catch (e) {
+			throw new MetamaskException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.SignArbitrary
+			});
+		}
+	}
+	async getEthereumChainId() {
+		try {
+			return Promise.resolve((this.chainId === ChainId.Mainnet ? EvmChainId.Mainnet : EvmChainId.Sepolia).toString(16));
+		} catch (e) {
+			throw new MetamaskException(new Error(e.message), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletError,
+				contextModule: WalletAction.GetChainId
+			});
+		}
+	}
+	async getEvmTransactionReceipt(_txHash) {
+		throw new WalletException(/* @__PURE__ */ new Error("Not supported"));
+	}
+	async getPubKey() {
+		return this.getPrivateKey().toPublicKey().toBase64();
+	}
+	async onChainIdChanged(_callback) {}
+	async onAccountChange(_callback) {}
+	getPrivateKey() {
+		if (!this.privateKey) {
+			var _this$metadata;
+			if (!((_this$metadata = this.metadata) === null || _this$metadata === void 0 || (_this$metadata = _this$metadata.privateKey) === null || _this$metadata === void 0 ? void 0 : _this$metadata.privateKey)) throw new WalletException(/* @__PURE__ */ new Error("Please provide private key in the constructor"), {
+				code: UnspecifiedErrorCode,
+				type: ErrorType.WalletNotInstalledError,
+				contextModule: WalletAction.GetAccounts
+			});
+			this.privateKey = PrivateKey.fromHex(this.metadata.privateKey.privateKey);
+		}
+		return this.privateKey;
+	}
+};
+
+//#endregion
+export { PrivateKeyWallet as PrivateKeyWalletStrategy };

package/dist/esm/package.json

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

package/package.json

@@ -1,73 +1,67 @@
 {
   "name": "@injectivelabs/wallet-private-key",
+  "version": "1.16.39-alpha.0",
   "description": "Private key wallet strategy for use with @injectivelabs/wallet-core.",
-  "version": "1.16.38",
-  "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-private-key": "dist"
-  },
+  "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "react-native": {
         "import": "./dist/esm/index.js",
-        "require": "./dist/cjs/index.js",
-        "types": "./dist/cjs/index.d.ts",
-        "default": "./dist/cjs/index.js"
+        "require": "./dist/cjs/index.cjs",
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
       },
       "require": {
-        "types": "./dist/cjs/index.d.ts",
-        "default": "./dist/cjs/index.js"
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
       },
       "import": {
         "types": "./dist/esm/index.d.ts",
         "default": "./dist/esm/index.js"
       },
       "default": {
-        "types": "./dist/cjs/index.d.ts",
-        "default": "./dist/cjs/index.js"
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
       }
     }
   },
-  "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",
-    "coverage:show": "live-server coverage",
-    "dev": "ts-node -r tsconfig-paths/register src/index.ts",
-    "start": "node dist/index.js"
-  },
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/cjs/index.d.cts",
+  "files": [
+    "dist"
+  ],
   "dependencies": {
-    "@injectivelabs/exceptions": "1.16.38",
-    "@injectivelabs/sdk-ts": "1.16.38",
-    "@injectivelabs/ts-types": "1.16.38",
-    "@injectivelabs/wallet-base": "1.16.38"
+    "@injectivelabs/ts-types": "1.16.39-alpha.0",
+    "@injectivelabs/sdk-ts": "1.16.39-alpha.0",
+    "@injectivelabs/exceptions": "1.16.39-alpha.0",
+    "@injectivelabs/wallet-base": "1.16.39-alpha.0"
   },
-  "devDependencies": {
-    "shx": "^0.3.4"
+  "publishConfig": {
+    "access": "public"
   },
-  "gitHead": "c67633f9ba4c5efb2c969c3df815d54995459966",
-  "typedoc": {
-    "entryPoint": "./src/index.ts",
-    "readmeFile": "./README.md",
-    "displayName": "wallet-private-key API Documentation"
+  "_moduleAliases": {
+    "~wallet-private-key": "dist"
+  },
+  "scripts": {
+    "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",
+    "lint": "eslint . --ext .ts,.js"
   }
-}
+}

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

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

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

@@ -1,36 +0,0 @@
-import { EvmChainId } from '@injectivelabs/ts-types';
-import { WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
-import type { AccountAddress } from '@injectivelabs/ts-types';
-import type { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
-import type { StdSignDoc, ConcreteWalletStrategy, SendTransactionOptions } from '@injectivelabs/wallet-base';
-export declare class PrivateKeyWallet extends BaseConcreteStrategy implements ConcreteWalletStrategy {
-    private privateKey?;
-    getWalletDeviceType(): Promise<WalletDeviceType>;
-    enable(): Promise<boolean>;
-    disconnect(): Promise<void>;
-    getAddresses(): Promise<string[]>;
-    getSessionOrConfirm(address: AccountAddress): Promise<string>;
-    sendEvmTransaction(_transaction: unknown, _options: {
-        address: AccountAddress;
-        evmChainId: EvmChainId;
-    }): Promise<string>;
-    sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
-    signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
-    signAminoCosmosTransaction(_transaction: {
-        address: string;
-        signDoc: StdSignDoc;
-    }): Promise<AminoSignResponse>;
-    signCosmosTransaction(_transaction: {
-        txRaw: TxRaw;
-        accountNumber: number;
-        chainId: string;
-        address: string;
-    }): Promise<DirectSignResponse>;
-    signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
-    getEthereumChainId(): Promise<string>;
-    getEvmTransactionReceipt(_txHash: string): Promise<string>;
-    getPubKey(): Promise<string>;
-    onChainIdChanged(_callback: (chain: string) => void): Promise<void>;
-    onAccountChange(_callback: (account: AccountAddress | string[]) => void): Promise<void>;
-    private getPrivateKey;
-}

package/dist/cjs/strategy/strategy.js

@@ -1,156 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrivateKeyWallet = void 0;
-const sdk_ts_1 = require("@injectivelabs/sdk-ts");
-const ts_types_1 = require("@injectivelabs/ts-types");
-const sdk_ts_2 = require("@injectivelabs/sdk-ts");
-const wallet_base_1 = require("@injectivelabs/wallet-base");
-const exceptions_1 = require("@injectivelabs/exceptions");
-class PrivateKeyWallet extends wallet_base_1.BaseConcreteStrategy {
-    privateKey;
-    async getWalletDeviceType() {
-        return Promise.resolve(wallet_base_1.WalletDeviceType.Other);
-    }
-    async enable() {
-        return Promise.resolve(true);
-    }
-    async disconnect() {
-        this.listeners = {};
-    }
-    async getAddresses() {
-        const pk = this.getPrivateKey();
-        try {
-            return Promise.resolve([pk.toAddress().toHex()]);
-        }
-        catch (e) {
-            throw new exceptions_1.MetamaskException(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.WalletException(new Error('This wallet does not support sending Evm transactions'), {
-            code: exceptions_1.UnspecifiedErrorCode,
-            type: exceptions_1.ErrorType.WalletError,
-            contextModule: 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 within the options for using Ethereum native wallets'));
-        }
-        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 pk = this.getPrivateKey();
-        if ((0, sdk_ts_2.getInjectiveSignerAddress)(address) !== pk.toAddress().toBech32()) {
-            throw new exceptions_1.WalletException(new Error('Signer address does not match the private key address'), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                type: exceptions_1.ErrorType.WalletError,
-                contextModule: wallet_base_1.WalletAction.SignTransaction,
-            });
-        }
-        try {
-            const signature = await pk.signTypedData(JSON.parse(eip712json));
-            return `0x${Buffer.from(signature).toString('hex')}`;
-        }
-        catch (e) {
-            throw new exceptions_1.MetamaskException(new Error(e.message), {
-                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 signing Cosmos transactions'), {
-            code: exceptions_1.UnspecifiedErrorCode,
-            type: exceptions_1.ErrorType.WalletError,
-            contextModule: wallet_base_1.WalletAction.SignTransaction,
-        });
-    }
-    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 signArbitrary(signer, data) {
-        const pk = this.getPrivateKey();
-        if ((0, sdk_ts_2.getInjectiveSignerAddress)(signer) !== pk.toAddress().toBech32()) {
-            throw new exceptions_1.WalletException(new Error('Signer address does not match the private key address'), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                type: exceptions_1.ErrorType.WalletError,
-                contextModule: wallet_base_1.WalletAction.SignArbitrary,
-            });
-        }
-        try {
-            const signature = await pk.signHashed(Buffer.from((0, sdk_ts_1.toUtf8)(data), 'utf-8'));
-            return `0x${Buffer.from(signature).toString('base64')}`;
-        }
-        catch (e) {
-            throw new exceptions_1.MetamaskException(new Error(e.message), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                type: exceptions_1.ErrorType.WalletError,
-                contextModule: wallet_base_1.WalletAction.SignArbitrary,
-            });
-        }
-    }
-    async getEthereumChainId() {
-        try {
-            return Promise.resolve((this.chainId === ts_types_1.ChainId.Mainnet
-                ? ts_types_1.EvmChainId.Mainnet
-                : ts_types_1.EvmChainId.Sepolia).toString(16));
-        }
-        catch (e) {
-            throw new exceptions_1.MetamaskException(new Error(e.message), {
-                code: exceptions_1.UnspecifiedErrorCode,
-                type: exceptions_1.ErrorType.WalletError,
-                contextModule: wallet_base_1.WalletAction.GetChainId,
-            });
-        }
-    }
-    async getEvmTransactionReceipt(_txHash) {
-        throw new exceptions_1.WalletException(new Error('Not supported'));
-    }
-    async getPubKey() {
-        const pk = this.getPrivateKey();
-        return pk.toPublicKey().toBase64();
-    }
-    async onChainIdChanged(_callback) {
-        //
-    }
-    async onAccountChange(_callback) {
-        //
-    }
-    getPrivateKey() {
-        if (!this.privateKey) {
-            if (!this.metadata?.privateKey?.privateKey) {
-                throw new exceptions_1.WalletException(new Error('Please provide private key in the constructor'), {
-                    code: exceptions_1.UnspecifiedErrorCode,
-                    type: exceptions_1.ErrorType.WalletNotInstalledError,
-                    contextModule: wallet_base_1.WalletAction.GetAccounts,
-                });
-            }
-            this.privateKey = sdk_ts_2.PrivateKey.fromHex(this.metadata.privateKey.privateKey);
-        }
-        return this.privateKey;
-    }
-}
-exports.PrivateKeyWallet = PrivateKeyWallet;

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

@@ -1,36 +0,0 @@
-import { EvmChainId } from '@injectivelabs/ts-types';
-import { WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
-import type { AccountAddress } from '@injectivelabs/ts-types';
-import type { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
-import type { StdSignDoc, ConcreteWalletStrategy, SendTransactionOptions } from '@injectivelabs/wallet-base';
-export declare class PrivateKeyWallet extends BaseConcreteStrategy implements ConcreteWalletStrategy {
-    private privateKey?;
-    getWalletDeviceType(): Promise<WalletDeviceType>;
-    enable(): Promise<boolean>;
-    disconnect(): Promise<void>;
-    getAddresses(): Promise<string[]>;
-    getSessionOrConfirm(address: AccountAddress): Promise<string>;
-    sendEvmTransaction(_transaction: unknown, _options: {
-        address: AccountAddress;
-        evmChainId: EvmChainId;
-    }): Promise<string>;
-    sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
-    signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
-    signAminoCosmosTransaction(_transaction: {
-        address: string;
-        signDoc: StdSignDoc;
-    }): Promise<AminoSignResponse>;
-    signCosmosTransaction(_transaction: {
-        txRaw: TxRaw;
-        accountNumber: number;
-        chainId: string;
-        address: string;
-    }): Promise<DirectSignResponse>;
-    signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
-    getEthereumChainId(): Promise<string>;
-    getEvmTransactionReceipt(_txHash: string): Promise<string>;
-    getPubKey(): Promise<string>;
-    onChainIdChanged(_callback: (chain: string) => void): Promise<void>;
-    onAccountChange(_callback: (account: AccountAddress | string[]) => void): Promise<void>;
-    private getPrivateKey;
-}

package/dist/esm/strategy/strategy.js

@@ -1,152 +0,0 @@
-import { toUtf8, TxGrpcApi } from '@injectivelabs/sdk-ts';
-import { ChainId, EvmChainId } from '@injectivelabs/ts-types';
-import { getInjectiveSignerAddress, PrivateKey as PrivateKeySigner, } from '@injectivelabs/sdk-ts';
-import { WalletAction, WalletDeviceType, BaseConcreteStrategy, } from '@injectivelabs/wallet-base';
-import { ErrorType, WalletException, MetamaskException, UnspecifiedErrorCode, TransactionException, } from '@injectivelabs/exceptions';
-export class PrivateKeyWallet extends BaseConcreteStrategy {
-    privateKey;
-    async getWalletDeviceType() {
-        return Promise.resolve(WalletDeviceType.Other);
-    }
-    async enable() {
-        return Promise.resolve(true);
-    }
-    async disconnect() {
-        this.listeners = {};
-    }
-    async getAddresses() {
-        const pk = this.getPrivateKey();
-        try {
-            return Promise.resolve([pk.toAddress().toHex()]);
-        }
-        catch (e) {
-            throw new MetamaskException(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 WalletException(new Error('This wallet does not support sending Evm transactions'), {
-            code: UnspecifiedErrorCode,
-            type: ErrorType.WalletError,
-            contextModule: WalletAction.SendEvmTransaction,
-        });
-    }
-    async sendTransaction(transaction, options) {
-        const { endpoints, txTimeout } = options;
-        if (!endpoints) {
-            throw new WalletException(new Error('You have to pass endpoints within the options for using Ethereum native wallets'));
-        }
-        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 pk = this.getPrivateKey();
-        if (getInjectiveSignerAddress(address) !== pk.toAddress().toBech32()) {
-            throw new WalletException(new Error('Signer address does not match the private key address'), {
-                code: UnspecifiedErrorCode,
-                type: ErrorType.WalletError,
-                contextModule: WalletAction.SignTransaction,
-            });
-        }
-        try {
-            const signature = await pk.signTypedData(JSON.parse(eip712json));
-            return `0x${Buffer.from(signature).toString('hex')}`;
-        }
-        catch (e) {
-            throw new MetamaskException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                type: ErrorType.WalletError,
-                contextModule: WalletAction.SignTransaction,
-            });
-        }
-    }
-    async signAminoCosmosTransaction(_transaction) {
-        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
-            code: UnspecifiedErrorCode,
-            type: ErrorType.WalletError,
-            contextModule: WalletAction.SignTransaction,
-        });
-    }
-    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 signArbitrary(signer, data) {
-        const pk = this.getPrivateKey();
-        if (getInjectiveSignerAddress(signer) !== pk.toAddress().toBech32()) {
-            throw new WalletException(new Error('Signer address does not match the private key address'), {
-                code: UnspecifiedErrorCode,
-                type: ErrorType.WalletError,
-                contextModule: WalletAction.SignArbitrary,
-            });
-        }
-        try {
-            const signature = await pk.signHashed(Buffer.from(toUtf8(data), 'utf-8'));
-            return `0x${Buffer.from(signature).toString('base64')}`;
-        }
-        catch (e) {
-            throw new MetamaskException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                type: ErrorType.WalletError,
-                contextModule: WalletAction.SignArbitrary,
-            });
-        }
-    }
-    async getEthereumChainId() {
-        try {
-            return Promise.resolve((this.chainId === ChainId.Mainnet
-                ? EvmChainId.Mainnet
-                : EvmChainId.Sepolia).toString(16));
-        }
-        catch (e) {
-            throw new MetamaskException(new Error(e.message), {
-                code: UnspecifiedErrorCode,
-                type: ErrorType.WalletError,
-                contextModule: WalletAction.GetChainId,
-            });
-        }
-    }
-    async getEvmTransactionReceipt(_txHash) {
-        throw new WalletException(new Error('Not supported'));
-    }
-    async getPubKey() {
-        const pk = this.getPrivateKey();
-        return pk.toPublicKey().toBase64();
-    }
-    async onChainIdChanged(_callback) {
-        //
-    }
-    async onAccountChange(_callback) {
-        //
-    }
-    getPrivateKey() {
-        if (!this.privateKey) {
-            if (!this.metadata?.privateKey?.privateKey) {
-                throw new WalletException(new Error('Please provide private key in the constructor'), {
-                    code: UnspecifiedErrorCode,
-                    type: ErrorType.WalletNotInstalledError,
-                    contextModule: WalletAction.GetAccounts,
-                });
-            }
-            this.privateKey = PrivateKeySigner.fromHex(this.metadata.privateKey.privateKey);
-        }
-        return this.privateKey;
-    }
-}