@injectivelabs/wallet-core 1.16.25-alpha.1 → 1.16.26

package/dist/esm/package.json

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

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

@@ -0,0 +1,58 @@
+import { Wallet, type WalletMetadata } from '@injectivelabs/wallet-base';
+import type { StdSignDoc } from '@keplr-wallet/types';
+import type { OfflineSigner } from '@cosmjs/proto-signing';
+import type { AccountAddress } from '@injectivelabs/ts-types';
+import type { ChainId, EvmChainId } from '@injectivelabs/ts-types';
+import type { WalletStrategyEmitter } from '../broadcaster/types.js';
+import type { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+import type { Eip1193Provider, WalletDeviceType, ConcreteStrategiesArg, SendTransactionOptions, ConcreteWalletStrategy, onAccountChangeCallback, onChainIdChangeCallback, WalletStrategyArguments, CosmosWalletAbstraction, WalletStrategy as WalletStrategyInterface } from '@injectivelabs/wallet-base';
+export default class BaseWalletStrategy implements WalletStrategyInterface {
+    strategies: ConcreteStrategiesArg;
+    wallet: Wallet;
+    args: WalletStrategyArguments;
+    metadata?: WalletMetadata;
+    wallets?: Wallet[];
+    private emitter;
+    on: WalletStrategyEmitter['on'];
+    off: WalletStrategyEmitter['off'];
+    emit: WalletStrategyEmitter['emit'];
+    constructor(args: WalletStrategyArguments);
+    getWallet(): Wallet;
+    setWallet(wallet: Wallet): void;
+    setMetadata(metadata?: WalletMetadata): void;
+    getStrategy(): ConcreteWalletStrategy;
+    getAddresses(args?: unknown): Promise<AccountAddress[]>;
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    getPubKey(address?: string): Promise<string>;
+    enable(args?: unknown): Promise<boolean>;
+    enableAndGetAddresses(args?: unknown): Promise<AccountAddress[]>;
+    getEthereumChainId(): Promise<string>;
+    getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): Promise<void>;
+    getSessionOrConfirm(address?: AccountAddress): Promise<string>;
+    getWalletClient<T>(): Promise<T>;
+    sendTransaction(tx: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+    sendEvmTransaction(tx: any, options: {
+        evmChainId: EvmChainId;
+        address: AccountAddress;
+    }): Promise<string>;
+    signEip712TypedData(eip712TypedData: string, address: AccountAddress, options?: {
+        txTimeout?: number;
+    }): Promise<string>;
+    signAminoCosmosTransaction(transaction: {
+        signDoc: StdSignDoc;
+        address: string;
+    }): Promise<AminoSignResponse>;
+    signCosmosTransaction(transaction: {
+        txRaw: TxRaw;
+        accountNumber: number;
+        chainId: string;
+        address: string;
+    }): Promise<DirectSignResponse>;
+    signArbitrary(signer: string, data: string | Uint8Array): Promise<string | void>;
+    onAccountChange(callback: onAccountChangeCallback): Promise<void>;
+    onChainIdChange(callback: onChainIdChangeCallback): Promise<void>;
+    disconnect(): Promise<void>;
+    getCosmosWallet(chainId: ChainId): CosmosWalletAbstraction;
+    getEip1193Provider(): Promise<Eip1193Provider>;
+    getOfflineSigner(chainId: string): Promise<OfflineSigner>;
+}

package/dist/esm/strategy/BaseWalletStrategy.js

@@ -0,0 +1,173 @@
+import { EventEmitter } from 'eventemitter3';
+import { GeneralException, WalletException } from '@injectivelabs/exceptions';
+import { Wallet, isEvmWallet, isCosmosWallet, } from '@injectivelabs/wallet-base';
+import { WalletStrategyEmitterEventType } from '../broadcaster/types.js';
+const getInitialWallet = (args) => {
+    if (args.wallet) {
+        return args.wallet;
+    }
+    const keys = Object.keys(args.strategies || {});
+    if (keys.length === 0) {
+        return Wallet.Metamask;
+    }
+    if (keys.includes(Wallet.Metamask) && args.evmOptions) {
+        return Wallet.Metamask;
+    }
+    if (keys.includes(Wallet.Keplr) && !args.evmOptions) {
+        return Wallet.Keplr;
+    }
+    return keys[0];
+};
+export default class BaseWalletStrategy {
+    strategies;
+    wallet;
+    args;
+    metadata;
+    wallets;
+    emitter;
+    on;
+    off;
+    emit;
+    constructor(args) {
+        this.args = args;
+        this.strategies = args.strategies;
+        this.wallet = getInitialWallet(args);
+        this.metadata = args.metadata;
+        this.emitter = new EventEmitter();
+        this.on = this.emitter.on.bind(this.emitter);
+        this.off = this.emitter.off.bind(this.emitter);
+        this.emit = this.emitter.emit.bind(this.emitter);
+    }
+    getWallet() {
+        return this.wallet;
+    }
+    setWallet(wallet) {
+        this.wallet = wallet;
+        this.getStrategy();
+    }
+    setMetadata(metadata) {
+        console.log('Setting metadata', metadata);
+        this.metadata = metadata;
+        this.getStrategy().setMetadata?.(metadata);
+    }
+    getStrategy() {
+        if (!this.strategies[this.wallet]) {
+            throw new GeneralException(new Error(`Wallet ${this.wallet} is not enabled/available!`));
+        }
+        return this.strategies[this.wallet];
+    }
+    getAddresses(args) {
+        return this.getStrategy().getAddresses(args);
+    }
+    getWalletDeviceType() {
+        return this.getStrategy().getWalletDeviceType();
+    }
+    getPubKey(address) {
+        return this.getStrategy().getPubKey(address);
+    }
+    enable(args) {
+        return this.getStrategy().enable(args);
+    }
+    async enableAndGetAddresses(args) {
+        await this.getStrategy().enable(args);
+        return this.getStrategy().getAddresses(args);
+    }
+    getEthereumChainId() {
+        return this.getStrategy().getEthereumChainId();
+    }
+    async getEvmTransactionReceipt(txHash, evmChainId) {
+        return this.getStrategy().getEvmTransactionReceipt(txHash, evmChainId);
+    }
+    async getSessionOrConfirm(address) {
+        return this.getStrategy().getSessionOrConfirm(address);
+    }
+    async getWalletClient() {
+        if (this.getStrategy()?.getWalletClient) {
+            const result = (this.getStrategy()?.getWalletClient)?.();
+            if (result) {
+                return result;
+            }
+        }
+        throw new WalletException(new Error('Wallet client not found. Please check your wallet strategy.'));
+    }
+    async sendTransaction(tx, options) {
+        return this.getStrategy().sendTransaction(tx, options);
+    }
+    async sendEvmTransaction(tx /* TODO */, options) {
+        return this.getStrategy().sendEvmTransaction(tx, options);
+    }
+    async signEip712TypedData(eip712TypedData, address, options = {}) {
+        if (isCosmosWallet(this.wallet)) {
+            throw new WalletException(new Error(`You can't sign Ethereum Transaction using ${this.wallet}`));
+        }
+        /** Phantom wallet needs enabling before signing */
+        if (this.wallet === Wallet.Phantom) {
+            await this.enable();
+        }
+        this.emit(WalletStrategyEmitterEventType.TransactionSignStart);
+        const response = await this.getStrategy().signEip712TypedData(eip712TypedData, address, options);
+        this.emit(WalletStrategyEmitterEventType.TransactionSigned);
+        return response;
+    }
+    async signAminoCosmosTransaction(transaction) {
+        if (isEvmWallet(this.wallet)) {
+            throw new WalletException(new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+        }
+        this.emit(WalletStrategyEmitterEventType.TransactionSignStart);
+        const response = await this.getStrategy().signAminoCosmosTransaction(transaction);
+        this.emit(WalletStrategyEmitterEventType.TransactionSigned);
+        return response;
+    }
+    async signCosmosTransaction(transaction) {
+        if (isEvmWallet(this.wallet)) {
+            throw new WalletException(new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+        }
+        this.emit(WalletStrategyEmitterEventType.TransactionSignStart);
+        const response = await this.getStrategy().signCosmosTransaction(transaction);
+        this.emit(WalletStrategyEmitterEventType.TransactionSigned);
+        return response;
+    }
+    async signArbitrary(signer, data) {
+        if (this.getStrategy().signArbitrary) {
+            this.emit(WalletStrategyEmitterEventType.TransactionSignStart);
+            const response = await this.getStrategy().signArbitrary(signer, data);
+            this.emit(WalletStrategyEmitterEventType.TransactionSigned);
+            return response;
+        }
+    }
+    async onAccountChange(callback) {
+        if (this.getStrategy().onAccountChange) {
+            return this.getStrategy().onAccountChange(callback);
+        }
+    }
+    async onChainIdChange(callback) {
+        if (this.getStrategy().onChainIdChange) {
+            return this.getStrategy().onChainIdChange(callback);
+        }
+    }
+    async disconnect() {
+        if (this.getStrategy().disconnect) {
+            await this.getStrategy().disconnect();
+            this.emit(WalletStrategyEmitterEventType.WalletStrategyDisconnect);
+        }
+    }
+    getCosmosWallet(chainId) {
+        const strategy = this.getStrategy();
+        if (strategy.getCosmosWallet == undefined) {
+            throw new WalletException(new Error(`This method is not available for ${this.getWallet()} wallet`));
+        }
+        return strategy.getCosmosWallet(chainId);
+    }
+    async getEip1193Provider() {
+        if (this.getStrategy().getEip1193Provider) {
+            return this.getStrategy().getEip1193Provider();
+        }
+        throw new WalletException(new Error('EIP1193 provider not found. Please check your wallet strategy.'));
+    }
+    async getOfflineSigner(chainId) {
+        if (this.getStrategy().getOfflineSigner) {
+            return this.getStrategy().getOfflineSigner(chainId);
+        }
+        throw new WalletException(new Error('Offline signer not found. Please check your wallet strategy.'));
+    }
+}

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

@@ -0,0 +1,2 @@
+import BaseWalletStrategy from './BaseWalletStrategy.js';
+export { BaseWalletStrategy };

package/dist/esm/strategy/index.js

@@ -0,0 +1,2 @@
+import BaseWalletStrategy from './BaseWalletStrategy.js';
+export { BaseWalletStrategy };

package/dist/esm/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './tx.js';

package/dist/esm/utils/index.js

@@ -0,0 +1 @@
+export * from './tx.js';

package/dist/esm/utils/tx.d.ts

@@ -0,0 +1 @@
+export declare const checkIfTxRunOutOfGas: (e: unknown) => boolean;

package/dist/esm/utils/tx.js

@@ -0,0 +1,7 @@
+import { TransactionException, ChainCosmosErrorCode, TransactionChainErrorModule, } from '@injectivelabs/exceptions';
+export const checkIfTxRunOutOfGas = (e) => {
+    return (e instanceof TransactionException &&
+        e.contextCode === ChainCosmosErrorCode.ErrOutOfGas &&
+        e.contextModule === TransactionChainErrorModule.CosmosSdk &&
+        e.originalMessage.includes('out of gas'));
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@injectivelabs/wallet-core",
   "description": "Core wallet strategy",
-  "version": "1.16.25-alpha.1",
+  "version": "1.16.26",
   "sideEffects": false,
   "type": "module",
   "author": {
@@ -41,32 +41,32 @@
     }
   },
   "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",
+    "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",
-    "lint": "eslint . --ext .ts,.js"
+    "start": "node dist/index.js"
   },
   "dependencies": {
-    "@injectivelabs/exceptions": "1.16.25-alpha.1",
-    "@injectivelabs/networks": "1.16.25-alpha.1",
-    "@injectivelabs/sdk-ts": "1.16.25-alpha.1",
-    "@injectivelabs/ts-types": "1.16.25-alpha.1",
-    "@injectivelabs/utils": "1.16.25-alpha.1",
-    "@injectivelabs/wallet-base": "1.16.25-alpha.1",
+    "@injectivelabs/exceptions": "1.16.26",
+    "@injectivelabs/networks": "1.16.26",
+    "@injectivelabs/sdk-ts": "1.16.26",
+    "@injectivelabs/ts-types": "1.16.26",
+    "@injectivelabs/utils": "1.16.26",
+    "@injectivelabs/wallet-base": "1.16.26",
     "@keplr-wallet/types": "^0.12.159",
     "eventemitter3": "^5.0.1"
   },
   "devDependencies": {
     "shx": "^0.3.3"
   },
-  "gitHead": "e59fe33d170260cc2214f5db7e48e0c7223dc37f"
+  "gitHead": "cc507916c46b41e6bc70a01744e23d43b12ebc65"
 }