@injectivelabs/wallet-cosmostation 1.16.38-alpha.7 → 1.16.38

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export { CosmostationWallet } from './wallet.js';
+export { Cosmostation as CosmostationWalletStrategy } from './strategy/strategy.js';
+export * from './utils/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmostationWalletStrategy = exports.CosmostationWallet = void 0;
+var wallet_js_1 = require("./wallet.js");
+Object.defineProperty(exports, "CosmostationWallet", { enumerable: true, get: function () { return wallet_js_1.CosmostationWallet; } });
+var strategy_js_1 = require("./strategy/strategy.js");
+Object.defineProperty(exports, "CosmostationWalletStrategy", { enumerable: true, get: function () { return strategy_js_1.Cosmostation; } });
+__exportStar(require("./utils/index.js"), exports);

package/dist/cjs/package.json

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

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

@@ -0,0 +1,43 @@
+import { CosmosChainId } from '@injectivelabs/ts-types';
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/sdk-ts';
+import { WalletDeviceType, BaseConcreteStrategy } from '@injectivelabs/wallet-base';
+import type { OfflineSigner } from '@cosmjs/proto-signing';
+import type { ChainId, EvmChainId, AccountAddress } from '@injectivelabs/ts-types';
+import type { StdSignDoc, ConcreteWalletStrategy } from '@injectivelabs/wallet-base';
+import type { TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+export declare class Cosmostation extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    private cosmostationWallet?;
+    chainName: string;
+    constructor(args: {
+        chainId: ChainId | CosmosChainId;
+    });
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    enable(): Promise<boolean>;
+    getAddresses(): Promise<string[]>;
+    getSessionOrConfirm(address?: AccountAddress): Promise<string>;
+    sendEvmTransaction(_transaction: unknown, _options: {
+        address: AccountAddress;
+        evmChainId: EvmChainId;
+    }): Promise<string>;
+    sendTransaction(transaction: DirectSignResponse | CosmosTxV1Beta1Tx.TxRaw, _options: {
+        address: AccountAddress;
+        chainId: ChainId;
+    }): Promise<TxResponse>;
+    signAminoCosmosTransaction(_transaction: {
+        address: string;
+        signDoc: StdSignDoc;
+    }): Promise<AminoSignResponse>;
+    signCosmosTransaction(transaction: {
+        txRaw: CosmosTxV1Beta1Tx.TxRaw;
+        chainId: string;
+        address: string;
+        accountNumber: number;
+    }): Promise<DirectSignResponse>;
+    getPubKey(): Promise<string>;
+    signEip712TypedData(_eip712TypedData: string, _address: AccountAddress): Promise<string>;
+    signArbitrary(signer: string, data: string | Uint8Array): Promise<string>;
+    getEthereumChainId(): Promise<string>;
+    getEvmTransactionReceipt(_txHash: string): Promise<string>;
+    getOfflineSigner(chainId: string): Promise<OfflineSigner>;
+    private getCosmostationWallet;
+}

package/dist/cjs/strategy/strategy.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cosmostation = void 0;
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const ts_types_1 = require("@injectivelabs/ts-types");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const extension_client_1 = require("@cosmostation/extension-client");
+const cosmos_client_1 = require("@cosmostation/cosmos-client");
+const cosmos_js_1 = require("@cosmostation/extension-client/cosmos.js");
+const sdk_ts_2 = require("@injectivelabs/sdk-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const wallet_js_1 = require("./../wallet.js");
+const getChainNameFromChainId = (chainId) => {
+    const [chainName] = chainId.split('-');
+    if (chainName.includes('cosmoshub')) {
+        return 'cosmos';
+    }
+    if (chainName.includes('core')) {
+        return 'persistence';
+    }
+    if (chainName.includes('evmos')) {
+        return 'evmos';
+    }
+    if (chainId.includes('ssc') || chainId.includes('fetch')) {
+        return chainId;
+    }
+    return chainName;
+};
+class Cosmostation extends wallet_base_1.BaseConcreteStrategy {
+    cosmostationWallet;
+    chainName;
+    constructor(args) {
+        super(args);
+        this.chainId = args.chainId || ts_types_1.CosmosChainId.Injective;
+        this.chainName = getChainNameFromChainId(this.chainId);
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(wallet_base_1.WalletDeviceType.Browser);
+    }
+    async enable() {
+        return Promise.resolve(true);
+    }
+    async getAddresses() {
+        const cosmostationWallet = await this.getCosmostationWallet();
+        try {
+            const accounts = await cosmostationWallet.requestAccount(this.chainName);
+            return [accounts.address];
+        }
+        catch (e) {
+            if (e.code === 4001) {
+                throw new exceptions_1.CosmosWalletException(new Error('The user rejected the request'), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    context: wallet_base_1.WalletAction.GetAccounts,
+                });
+            }
+            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 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. Cosmostation only supports sending cosmos transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.SendEvmTransaction,
+        });
+    }
+    async sendTransaction(transaction, _options) {
+        const cosmostationWallet = await this.getCosmostationWallet();
+        const txRaw = (0, sdk_ts_2.createTxRawFromSigResponse)(transaction);
+        try {
+            const response = await cosmostationWallet.sendTransaction(this.chainName, sdk_ts_1.CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish(), cosmos_js_1.SEND_TRANSACTION_MODE.SYNC);
+            return {
+                ...response.tx_response,
+                gasUsed: parseInt((response.tx_response.gas_used || '0'), 10),
+                gasWanted: parseInt((response.tx_response.gas_wanted || '0'), 10),
+                height: parseInt((response.tx_response.height || '0'), 10),
+                txHash: response.tx_response.txhash,
+                rawLog: response.tx_response.raw_log,
+            };
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.TransactionException) {
+                throw e;
+            }
+            throw new exceptions_1.TransactionException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: wallet_base_1.WalletAction.SendTransaction,
+            });
+        }
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new exceptions_1.CosmosWalletException(new Error('This wallet does not support signing using amino'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.SendTransaction,
+        });
+    }
+    async signCosmosTransaction(transaction) {
+        const { chainId } = this;
+        const cosmostationWallet = await this.getCosmostationWallet();
+        const signDoc = (0, sdk_ts_2.createSignDocFromTransaction)(transaction);
+        try {
+            /* Sign the transaction */
+            const signDirectResponse = await cosmostationWallet.signDirect(this.chainName, {
+                chain_id: chainId,
+                body_bytes: signDoc.bodyBytes,
+                auth_info_bytes: signDoc.authInfoBytes,
+                account_number: signDoc.accountNumber.toString(),
+            }, { fee: true, memo: true });
+            return {
+                signed: (0, proto_signing_1.makeSignDoc)(signDirectResponse.signed_doc.body_bytes, signDirectResponse.signed_doc.auth_info_bytes, signDirectResponse.signed_doc.chain_id, parseInt(signDirectResponse.signed_doc.account_number, 10)),
+                signature: {
+                    signature: signDirectResponse.signature,
+                },
+            };
+        }
+        catch (e) {
+            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: wallet_base_1.WalletAction.SendTransaction,
+            });
+        }
+    }
+    async getPubKey() {
+        const cosmostationWallet = await this.getCosmostationWallet();
+        try {
+            const account = await cosmostationWallet.requestAccount(this.chainName);
+            return Buffer.from(account.publicKey).toString('base64');
+        }
+        catch (e) {
+            if (e.code === 4001) {
+                throw new exceptions_1.CosmosWalletException(new Error('The user rejected the request'), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    context: wallet_base_1.WalletAction.GetAccounts,
+                });
+            }
+            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: wallet_base_1.WalletAction.GetAccounts,
+            });
+        }
+    }
+    async signEip712TypedData(_eip712TypedData, _address) {
+        throw new exceptions_1.CosmosWalletException(new Error('This wallet does not support signing Evm transactions'), {
+            code: exceptions_1.UnspecifiedErrorCode,
+            context: wallet_base_1.WalletAction.SendTransaction,
+        });
+    }
+    async signArbitrary(signer, data) {
+        try {
+            const cosmostationWallet = await this.getCosmostationWallet();
+            const signature = await cosmostationWallet.signMessage(this.chainName, signer, (0, sdk_ts_2.toUtf8)(data));
+            return signature.signature;
+        }
+        catch (e) {
+            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: wallet_base_1.WalletAction.SignArbitrary,
+            });
+        }
+    }
+    async getEthereumChainId() {
+        throw new exceptions_1.CosmosWalletException(new Error('getEthereumChainId is not supported on Cosmostation'), {
+            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 getOfflineSigner(chainId) {
+        return (await (0, cosmos_client_1.getOfflineSigner)(chainId));
+    }
+    async getCosmostationWallet() {
+        if (this.cosmostationWallet) {
+            return this.cosmostationWallet;
+        }
+        const cosmostationWallet = new wallet_js_1.CosmostationWallet(this.chainId);
+        try {
+            const provider = await cosmostationWallet.getCosmostationWallet();
+            this.cosmostationWallet = provider;
+            return provider;
+        }
+        catch (e) {
+            if (e instanceof extension_client_1.InstallError) {
+                throw new exceptions_1.CosmosWalletException(new Error('Please install the Cosmostation extension'), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    type: exceptions_1.ErrorType.WalletNotInstalledError,
+                });
+            }
+            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+            });
+        }
+    }
+}
+exports.Cosmostation = Cosmostation;

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

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

package/dist/cjs/utils/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCosmosStationWalletInstalled = void 0;
+const isCosmosStationWalletInstalled = () => {
+    const $window = (typeof window !== 'undefined' ? window : {});
+    return $window.cosmostation !== undefined;
+};
+exports.isCosmosStationWalletInstalled = isCosmosStationWalletInstalled;

package/dist/cjs/wallet.d.ts

@@ -0,0 +1,8 @@
+import type { ChainId, CosmosChainId, TestnetCosmosChainId } from '@injectivelabs/ts-types';
+export declare class CosmostationWallet {
+    private chainId;
+    constructor(chainId: CosmosChainId | TestnetCosmosChainId | ChainId);
+    static isChainIdSupported(chainId: CosmosChainId): Promise<boolean>;
+    checkChainIdSupport(): Promise<boolean>;
+    getCosmostationWallet(): Promise<typeof import("@cosmostation/extension-client/cosmos")>;
+}

package/dist/cjs/wallet.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmostationWallet = void 0;
+const extension_client_1 = require("@cosmostation/extension-client");
+const exceptions_1 = require("@injectivelabs/exceptions");
+class CosmostationWallet {
+    chainId;
+    constructor(chainId) {
+        this.chainId = chainId;
+    }
+    static async isChainIdSupported(chainId) {
+        return new CosmostationWallet(chainId).checkChainIdSupport();
+    }
+    async checkChainIdSupport() {
+        const { chainId: actualChainId } = this;
+        const provider = await this.getCosmostationWallet();
+        const chainName = actualChainId.split('-');
+        try {
+            const supportedChainIds = await provider.getSupportedChainIds();
+            return !!supportedChainIds.official.find((chainId) => chainId === actualChainId);
+        }
+        catch {
+            throw new exceptions_1.CosmosWalletException(new Error(`Cosmostation doesn't support ${chainName[0] || actualChainId} network. Please use another Cosmos wallet`));
+        }
+    }
+    async getCosmostationWallet() {
+        try {
+            const provider = await (0, extension_client_1.cosmos)();
+            return provider;
+        }
+        catch (e) {
+            if (e instanceof extension_client_1.InstallError) {
+                throw new exceptions_1.CosmosWalletException(new Error('Please install the Cosmostation extension'), {
+                    code: exceptions_1.UnspecifiedErrorCode,
+                    type: exceptions_1.ErrorType.WalletNotInstalledError,
+                });
+            }
+            throw new exceptions_1.CosmosWalletException(new Error(e.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+            });
+        }
+    }
+}
+exports.CosmostationWallet = CosmostationWallet;

package/dist/esm/index.d.ts

@@ -1,64 +1,3 @@
-import { OfflineSigner } from "@cosmjs/proto-signing";
-import { AccountAddress, ChainId, CosmosChainId, EvmChainId, TestnetCosmosChainId } from "@injectivelabs/ts-types";
-import { CosmosTxV1Beta1TxPb } from "@injectivelabs/sdk-ts";
-import { TxResponse } from "@injectivelabs/sdk-ts/core/tx";
-import { BaseConcreteStrategy, ConcreteWalletStrategy, StdSignDoc, WalletDeviceType } from "@injectivelabs/wallet-base";
-import * as _cosmostation_extension_client_cosmos0 from "@cosmostation/extension-client/cosmos";
-import { AminoSignResponse, DirectSignResponse } from "@injectivelabs/sdk-ts/types";
-
-//#region src/utils/index.d.ts
-declare const isCosmosStationWalletInstalled: () => boolean;
-//#endregion
-//#region src/wallet.d.ts
-declare class CosmostationWallet {
-  private chainId;
-  constructor(chainId: CosmosChainId | TestnetCosmosChainId | ChainId);
-  static isChainIdSupported(chainId: CosmosChainId): Promise<boolean>;
-  checkChainIdSupport(): Promise<boolean>;
-  getCosmostationWallet(): Promise<typeof _cosmostation_extension_client_cosmos0>;
-}
-//#endregion
-//#region src/strategy/strategy.d.ts
-declare class Cosmostation extends BaseConcreteStrategy implements ConcreteWalletStrategy {
-  private cosmostationWallet?;
-  chainName: string;
-  constructor(args: {
-    chainId: ChainId | CosmosChainId;
-  });
-  getWalletDeviceType(): Promise<WalletDeviceType>;
-  enable(): Promise<boolean>;
-  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: DirectSignResponse | CosmosTxV1Beta1TxPb.TxRaw, _options: {
-    address: AccountAddress;
-    chainId: ChainId;
-  }): Promise<TxResponse>;
-  signAminoCosmosTransaction(_transaction: {
-    address: string;
-    signDoc: StdSignDoc;
-  }): Promise<AminoSignResponse>;
-  signCosmosTransaction(transaction: {
-    txRaw: CosmosTxV1Beta1TxPb.TxRaw;
-    chainId: string;
-    address: string;
-    accountNumber: number;
-  }): Promise<DirectSignResponse>;
-  getPubKey(): Promise<string>;
-  signEip712TypedData(_eip712TypedData: string, _address: AccountAddress): Promise<string>;
-  signArbitrary(signer: string, data: string | Uint8Array): Promise<string>;
-  getEthereumChainId(): Promise<string>;
-  getEvmTransactionReceipt(_txHash: string): Promise<string>;
-  getOfflineSigner(chainId: string): Promise<OfflineSigner>;
-  private getCosmostationWallet;
-}
-//#endregion
-export { CosmostationWallet, Cosmostation as CosmostationWalletStrategy, isCosmosStationWalletInstalled };
+export { CosmostationWallet } from './wallet.js';
+export { Cosmostation as CosmostationWalletStrategy } from './strategy/strategy.js';
+export * from './utils/index.js';