@injectivelabs/wallet-core 1.15.0 → 1.15.2

package/dist/cjs/broadcaster/Web3Broadcaster.d.ts

@@ -0,0 +1,29 @@
+import { EthereumChainId } from '@injectivelabs/ts-types';
+import { Network } from '@injectivelabs/networks';
+import BaseWalletStrategy from '../strategy/BaseWalletStrategy.js';
+interface SendTransactionOptions {
+    tx: {
+        from: string;
+        to: string;
+        gas: string;
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string | null;
+        data: any;
+    };
+    address: string;
+}
+/**
+ * Preparing and broadcasting
+ * Ethereum transactions
+ */
+export declare class Web3Broadcaster {
+    private walletStrategy;
+    private ethereumChainId;
+    constructor({ walletStrategy, ethereumChainId, }: {
+        walletStrategy: BaseWalletStrategy;
+        ethereumChainId: EthereumChainId;
+        network: Network;
+    });
+    sendTransaction(args: SendTransactionOptions): Promise<string>;
+}
+export {};

package/dist/cjs/broadcaster/Web3Broadcaster.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Web3Broadcaster = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+/**
+ * Preparing and broadcasting
+ * Ethereum transactions
+ */
+class Web3Broadcaster {
+    walletStrategy;
+    ethereumChainId;
+    constructor({ walletStrategy, ethereumChainId, }) {
+        this.walletStrategy = walletStrategy;
+        this.ethereumChainId = ethereumChainId;
+    }
+    async sendTransaction(args) {
+        const { walletStrategy, ethereumChainId } = this;
+        try {
+            const txHash = await walletStrategy.sendEthereumTransaction(args.tx, {
+                ethereumChainId,
+                address: args.address,
+            });
+            await walletStrategy.getEthereumTransactionReceipt(txHash);
+            return txHash;
+        }
+        catch (e) {
+            throw new exceptions_1.Web3Exception(new Error(e.message));
+        }
+    }
+}
+exports.Web3Broadcaster = Web3Broadcaster;

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

@@ -0,0 +1,3 @@
+export * from './MsgBroadcaster.js';
+export * from './Web3Broadcaster.js';
+export * from './types.js';

package/dist/cjs/broadcaster/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./MsgBroadcaster.js"), exports);
+__exportStar(require("./Web3Broadcaster.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/cjs/broadcaster/types.d.ts

@@ -0,0 +1,32 @@
+import { Msgs } from '@injectivelabs/sdk-ts';
+import { ChainId, EthereumChainId } from '@injectivelabs/ts-types';
+import { Network, NetworkEndpoints } from '@injectivelabs/networks';
+import BaseWalletStrategy from '../strategy/BaseWalletStrategy.js';
+export interface MsgBroadcasterTxOptions {
+    memo?: string;
+    ethereumAddress?: string;
+    injectiveAddress?: string;
+    msgs: Msgs | Msgs[];
+    gas?: {
+        gasPrice?: string;
+        gas?: number; /** gas limit */
+        feePayer?: string;
+        granter?: string;
+    };
+}
+export interface MsgBroadcasterTxOptionsWithAddresses extends MsgBroadcasterTxOptions {
+    ethereumAddress: string;
+    injectiveAddress: string;
+}
+export interface MsgBroadcasterOptions {
+    network: Network;
+    endpoints?: NetworkEndpoints;
+    chainId?: ChainId;
+    ethereumChainId?: EthereumChainId;
+    feePayerPubKey?: string;
+    simulateTx?: boolean;
+    txTimeoutOnFeeDelegation?: boolean;
+    txTimeout?: number;
+    walletStrategy: BaseWalletStrategy;
+    gasBufferCoefficient?: number;
+}

package/dist/cjs/broadcaster/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './broadcaster/index.js';
+export * from './strategy/index.js';
+export * from './utils/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./broadcaster/index.js"), exports);
+__exportStar(require("./strategy/index.js"), exports);
+__exportStar(require("./utils/index.js"), exports);

package/dist/cjs/package.json

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

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

@@ -0,0 +1,44 @@
+import { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+import { ChainId, AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+import { Wallet, WalletDeviceType, ConcreteStrategiesArg, SendTransactionOptions, ConcreteWalletStrategy, onAccountChangeCallback, onChainIdChangeCallback, WalletStrategyArguments, CosmosWalletAbstraction, ConcreteWalletStrategyOptions, WalletStrategy as WalletStrategyInterface } from '@injectivelabs/wallet-base';
+import { StdSignDoc } from '@keplr-wallet/types';
+export default class BaseWalletStrategy implements WalletStrategyInterface {
+    strategies: ConcreteStrategiesArg;
+    wallet: Wallet;
+    args: WalletStrategyArguments;
+    wallets?: Wallet[];
+    constructor(args: WalletStrategyArguments);
+    getWallet(): Wallet;
+    setWallet(wallet: Wallet): void;
+    setOptions(_options?: ConcreteWalletStrategyOptions): 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>;
+    getEthereumTransactionReceipt(txHash: string): Promise<void>;
+    getSessionOrConfirm(address?: AccountAddress): Promise<string>;
+    sendTransaction(tx: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+    sendEthereumTransaction(tx: any, options: {
+        address: AccountAddress;
+        ethereumChainId: EthereumChainId;
+    }): Promise<string>;
+    signEip712TypedData(eip712TypedData: string, address: AccountAddress): 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;
+}

package/dist/cjs/strategy/BaseWalletStrategy.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const exceptions_1 = require("@injectivelabs/exceptions");
+const wallet_base_1 = require("@injectivelabs/wallet-base");
+const getInitialWallet = (args) => {
+    if (args.wallet) {
+        return args.wallet;
+    }
+    const keys = Object.keys(args.strategies || {});
+    if (keys.length === 0) {
+        throw new exceptions_1.GeneralException(new Error('No strategies provided to BaseWalletStrategy'));
+    }
+    if (keys.includes(wallet_base_1.Wallet.Metamask) && args.ethereumOptions) {
+        return wallet_base_1.Wallet.Metamask;
+    }
+    if (keys.includes(wallet_base_1.Wallet.Keplr) && !args.ethereumOptions) {
+        return wallet_base_1.Wallet.Keplr;
+    }
+    return keys[0];
+};
+class BaseWalletStrategy {
+    strategies;
+    wallet;
+    args;
+    wallets;
+    constructor(args) {
+        this.args = args;
+        this.strategies = args.strategies;
+        this.wallet = getInitialWallet(args);
+    }
+    getWallet() {
+        return this.wallet;
+    }
+    setWallet(wallet) {
+        this.wallet = wallet;
+    }
+    setOptions(_options) {
+        //
+    }
+    getStrategy() {
+        if (!this.strategies[this.wallet]) {
+            throw new exceptions_1.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 getEthereumTransactionReceipt(txHash) {
+        return this.getStrategy().getEthereumTransactionReceipt(txHash);
+    }
+    async getSessionOrConfirm(address) {
+        return this.getStrategy().getSessionOrConfirm(address);
+    }
+    async sendTransaction(tx, options) {
+        return this.getStrategy().sendTransaction(tx, options);
+    }
+    async sendEthereumTransaction(tx /* TODO */, options) {
+        return this.getStrategy().sendEthereumTransaction(tx, options);
+    }
+    async signEip712TypedData(eip712TypedData, address) {
+        if ((0, wallet_base_1.isCosmosWallet)(this.wallet)) {
+            throw new exceptions_1.WalletException(new Error(`You can't sign Ethereum Transaction using ${this.wallet}`));
+        }
+        /** Phantom wallet needs enabling before signing */
+        if (this.wallet === wallet_base_1.Wallet.Phantom) {
+            await this.enable();
+        }
+        return this.getStrategy().signEip712TypedData(eip712TypedData, address);
+    }
+    async signAminoCosmosTransaction(transaction) {
+        if ((0, wallet_base_1.isEvmWallet)(this.wallet)) {
+            throw new exceptions_1.WalletException(new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+        }
+        return this.getStrategy().signAminoCosmosTransaction(transaction);
+    }
+    async signCosmosTransaction(transaction) {
+        if ((0, wallet_base_1.isEvmWallet)(this.wallet)) {
+            throw new exceptions_1.WalletException(new Error(`You can't sign Cosmos Transaction using ${this.wallet}`));
+        }
+        return this.getStrategy().signCosmosTransaction(transaction);
+    }
+    async signArbitrary(signer, data) {
+        if (this.getStrategy().signArbitrary) {
+            return this.getStrategy().signArbitrary(signer, data);
+        }
+    }
+    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();
+        }
+    }
+    getCosmosWallet(chainId) {
+        const strategy = this.getStrategy();
+        if (strategy.getCosmosWallet == undefined) {
+            throw new exceptions_1.WalletException(new Error(`This method is not available for ${this.getWallet()} wallet`));
+        }
+        return strategy.getCosmosWallet(chainId);
+    }
+}
+exports.default = BaseWalletStrategy;

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

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

package/dist/cjs/strategy/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseWalletStrategy = void 0;
+const BaseWalletStrategy_js_1 = __importDefault(require("./BaseWalletStrategy.js"));
+exports.BaseWalletStrategy = BaseWalletStrategy_js_1.default;

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

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

package/dist/cjs/utils/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./tx.js"), exports);

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

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

package/dist/cjs/utils/tx.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfTxRunOutOfGas = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const checkIfTxRunOutOfGas = (e) => {
+    return (e instanceof exceptions_1.TransactionException &&
+        e.contextCode === exceptions_1.ChainCosmosErrorCode.ErrOutOfGas &&
+        e.contextModule === exceptions_1.TransactionChainErrorModule.CosmosSdk &&
+        e.originalMessage.includes('out of gas'));
+};
+exports.checkIfTxRunOutOfGas = checkIfTxRunOutOfGas;

package/dist/esm/broadcaster/MsgBroadcaster.d.ts

@@ -0,0 +1,132 @@
+import { TxResponse } from '@injectivelabs/sdk-ts';
+import { NetworkEndpoints } from '@injectivelabs/networks';
+import { ChainId, EthereumChainId } from '@injectivelabs/ts-types';
+import { MsgBroadcasterOptions, MsgBroadcasterTxOptions } from './types.js';
+import BaseWalletStrategy from '../strategy/BaseWalletStrategy.js';
+/**
+ * This class is used to broadcast transactions
+ * using the WalletStrategy as a handler
+ * for the sign/broadcast flow of the transactions
+ *
+ * Mainly used for building UI products
+ */
+export declare class MsgBroadcaster {
+    options: MsgBroadcasterOptions;
+    walletStrategy: BaseWalletStrategy;
+    endpoints: NetworkEndpoints;
+    chainId: ChainId;
+    txTimeout: number;
+    simulateTx: boolean;
+    txTimeoutOnFeeDelegation: boolean;
+    ethereumChainId?: EthereumChainId;
+    gasBufferCoefficient: number;
+    retriesOnError: {
+        "sdk-20": {
+            retries: number;
+            maxRetries: number;
+            timeout: number;
+        };
+    };
+    constructor(options: MsgBroadcasterOptions);
+    setOptions(options: Partial<MsgBroadcasterOptions>): void;
+    /**
+     * Broadcasting the transaction using the client
+     * side approach for both cosmos and ethereum native wallets
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    broadcast(tx: MsgBroadcasterTxOptions): Promise<TxResponse>;
+    /**
+     * Broadcasting the transaction using the client
+     * side approach for both cosmos and ethereum native wallets
+     * Note: using EIP712_V2 for Ethereum wallets
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    broadcastV2(tx: MsgBroadcasterTxOptions): Promise<TxResponse>;
+    /**
+     * Broadcasting the transaction using the feeDelegation
+     * support approach for both cosmos and ethereum native wallets
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    broadcastWithFeeDelegation(tx: MsgBroadcasterTxOptions): Promise<TxResponse>;
+    /**
+     * Prepare/sign/broadcast transaction using
+     * Ethereum native wallets on the client side.
+     *
+     * Note: Gas estimation not available
+     *
+     * @param tx The transaction that needs to be broadcasted
+     * @returns transaction hash
+     */
+    private broadcastEip712;
+    /**
+     * Prepare/sign/broadcast transaction using
+     * Ethereum native wallets on the client side.
+     *
+     * Note: Gas estimation not available
+     *
+     * @param tx The transaction that needs to be broadcasted
+     * @returns transaction hash
+     */
+    private broadcastEip712V2;
+    /**
+     * Prepare/sign/broadcast transaction using
+     * Ethereum native wallets using the Web3Gateway.
+     *
+     * @param tx The transaction that needs to be broadcasted
+     * @returns transaction hash
+     */
+    private broadcastEip712WithFeeDelegation;
+    /**
+     * Prepare/sign/broadcast transaction using
+     * Cosmos native wallets on the client side.
+     *
+     * @param tx The transaction that needs to be broadcasted
+     * @returns transaction hash
+     */
+    private broadcastDirectSign;
+    /**
+     * We use this method only when we want to broadcast a transaction using Ledger on Keplr/Leap for Injective
+     *
+     * Note: Gas estimation not available
+     * @param tx the transaction that needs to be broadcasted
+     */
+    private experimentalBroadcastWalletThroughLedger;
+    /**
+     * Prepare/sign/broadcast transaction using
+     * Cosmos native wallets using the Web3Gateway.
+     *
+     * @param tx The transaction that needs to be broadcasted
+     * @returns transaction hash
+     */
+    private broadcastDirectSignWithFeeDelegation;
+    /**
+     * Fetch the fee payer's pub key from the web3 gateway
+     *
+     * Returns a base64 version of it
+     */
+    private fetchFeePayerPubKey;
+    /**
+     * In case we don't want to simulate the transaction
+     * we get the gas limit based on the message type.
+     *
+     * If we want to simulate the transaction we set the
+     * gas limit based on the simulation and add a small multiplier
+     * to be safe (factor of 1.2 as default)
+     */
+    private getTxWithSignersAndStdFee;
+    /**
+     * Create TxRaw and simulate it
+     */
+    private simulateTxRaw;
+    /**
+     * Create TxRaw and simulate it
+     */
+    private simulateTxWithSigners;
+    private retryOnException;
+}