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

package/dist/esm/package.json

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

package/dist/esm/types/enums.d.ts

@@ -0,0 +1,64 @@
+export declare const BroadcastMode: {
+    readonly Block: "block";
+    readonly Sync: "sync";
+    readonly Async: "async";
+};
+export type BroadcastMode = (typeof BroadcastMode)[keyof typeof BroadcastMode];
+export declare const Wallet: {
+    readonly Leap: "leap";
+    readonly Keplr: "keplr";
+    readonly Ninji: "ninji";
+    readonly Magic: "magic";
+    readonly Rabby: "rabby";
+    readonly Ledger: "ledger";
+    readonly BitGet: "BitGet";
+    readonly OWallet: "owallet";
+    readonly Phantom: "phantom";
+    readonly Rainbow: "rainbow";
+    readonly Turnkey: "turnkey";
+    readonly Metamask: "metamask";
+    readonly OkxWallet: "okx-wallet";
+    readonly PrivateKey: "private-key";
+    readonly TrustWallet: "trust-wallet";
+    readonly TrezorBip32: "trezor-bip32";
+    readonly TrezorBip44: "trezor-bip44";
+    readonly Cosmostation: "cosmostation";
+    readonly LedgerCosmos: "ledger-cosmos";
+    readonly LedgerLegacy: "ledger-legacy";
+    readonly WalletConnect: "wallet-connect";
+    readonly CosmostationEth: "cosmostation-eth";
+};
+export type Wallet = (typeof Wallet)[keyof typeof Wallet];
+export declare const MagicProvider: {
+    readonly Email: "email";
+    readonly Apple: "apple";
+    readonly Github: "github";
+    readonly Google: "google";
+    readonly Discord: "discord";
+    readonly Twitter: "twitter";
+    readonly Facebook: "facebook";
+};
+export type MagicProvider = (typeof MagicProvider)[keyof typeof MagicProvider];
+export declare const WalletDeviceType: {
+    readonly Mobile: "mobile";
+    readonly Other: "other";
+    readonly Browser: "browser";
+    readonly Hardware: "hardware";
+};
+export type WalletDeviceType = (typeof WalletDeviceType)[keyof typeof WalletDeviceType];
+export declare const WalletEventListener: {
+    readonly AccountChange: "account-change";
+    readonly ChainIdChange: "chain-id-change";
+};
+export type WalletEventListener = (typeof WalletEventListener)[keyof typeof WalletEventListener];
+export declare const WalletAction: {
+    GetChainId: "get-chain-id";
+    GetAccounts: "get-accounts";
+    GetNetworkId: "get-network-id";
+    SignArbitrary: "sign-arbitrary";
+    SignTransaction: "sign-transaction";
+    SendTransaction: "send-transaction";
+    SendEvmTransaction: "send-evm-transaction";
+    SignEvmTransaction: "sign-evm-transaction";
+    GetEvmTransactionReceipt: "get-evm-transaction-receipt";
+};

package/dist/esm/types/enums.js

@@ -0,0 +1,50 @@
+import { WalletErrorActionModule } from '@injectivelabs/exceptions';
+export const BroadcastMode = {
+    Block: 'block',
+    Sync: 'sync',
+    Async: 'async',
+};
+export const Wallet = {
+    Leap: 'leap',
+    Keplr: 'keplr',
+    Ninji: 'ninji',
+    Magic: 'magic',
+    Rabby: 'rabby',
+    Ledger: 'ledger',
+    BitGet: 'BitGet',
+    OWallet: 'owallet',
+    Phantom: 'phantom',
+    Rainbow: 'rainbow',
+    Turnkey: 'turnkey',
+    Metamask: 'metamask',
+    OkxWallet: 'okx-wallet',
+    PrivateKey: 'private-key',
+    TrustWallet: 'trust-wallet',
+    TrezorBip32: 'trezor-bip32',
+    TrezorBip44: 'trezor-bip44',
+    Cosmostation: 'cosmostation',
+    LedgerCosmos: 'ledger-cosmos',
+    LedgerLegacy: 'ledger-legacy',
+    WalletConnect: 'wallet-connect',
+    CosmostationEth: 'cosmostation-eth',
+};
+export const MagicProvider = {
+    Email: 'email',
+    Apple: 'apple',
+    Github: 'github',
+    Google: 'google',
+    Discord: 'discord',
+    Twitter: 'twitter',
+    Facebook: 'facebook',
+};
+export const WalletDeviceType = {
+    Mobile: 'mobile',
+    Other: 'other',
+    Browser: 'browser',
+    Hardware: 'hardware',
+};
+export const WalletEventListener = {
+    AccountChange: 'account-change',
+    ChainIdChange: 'chain-id-change',
+};
+export const WalletAction = { ...WalletErrorActionModule };

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

@@ -0,0 +1,3 @@
+export * from './enums.js';
+export * from './strategy.js';
+export type * from './provider.js';

package/dist/esm/types/index.js

@@ -0,0 +1,2 @@
+export * from './enums.js';
+export * from './strategy.js';

package/dist/esm/types/provider.d.ts

@@ -0,0 +1,38 @@
+import type { EIP1193Provider } from 'eip1193-provider';
+export interface BrowserEip1993Provider extends EIP1193Provider {
+    removeAllListeners(): void;
+    isTrust: boolean;
+    isRabby: boolean;
+    isRainbow: boolean;
+    isPhantom: boolean;
+    isMetaMask: boolean;
+    isOkxWallet: boolean;
+    isTrustWallet: boolean;
+}
+export interface WindowWithEip1193Provider extends Window {
+    rainbow: BrowserEip1993Provider;
+    rabby: BrowserEip1993Provider;
+    ethereum: BrowserEip1993Provider;
+    okxwallet: BrowserEip1993Provider;
+    providers: BrowserEip1993Provider[];
+    trustWallet?: BrowserEip1993Provider;
+    bitkeep: {
+        ethereum: BrowserEip1993Provider;
+    };
+    phantom?: {
+        ethereum?: BrowserEip1993Provider;
+    };
+}
+export interface EIP6963ProviderInfo {
+    rdns: string;
+    uuid: string;
+    name: string;
+    icon: string;
+}
+export interface EIP6963ProviderDetail {
+    info: EIP6963ProviderInfo;
+    provider: BrowserEip1993Provider;
+}
+export type EIP6963AnnounceProviderEvent = {
+    detail: EIP6963ProviderDetail;
+};

package/dist/esm/types/provider.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,256 @@
+import type { StdSignDoc } from '@keplr-wallet/types';
+import type { WalletDeviceType, Wallet } from './enums.js';
+import type { OfflineSigner } from '@cosmjs/proto-signing';
+import type { ChainId, EvmChainId, AccountAddress } from '@injectivelabs/ts-types';
+import type { TxRaw, TxResponse, AminoSignResponse, DirectSignResponse } from '@injectivelabs/sdk-ts';
+export type onAccountChangeCallback = (account: string | string[]) => void;
+export type onChainIdChangeCallback = () => void;
+export type Eip1193Provider = {
+    request: (args: {
+        method: string;
+        params: any[];
+    }) => Promise<any>;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+    removeListener: (event: string, listener: (...args: any[]) => void) => void;
+};
+export type CosmosWalletAbstraction = {
+    enableGasCheck?(chainId: ChainId): Promise<void> | void;
+    disableGasCheck?(chainId: ChainId): Promise<void> | void;
+    signEIP712CosmosTx(args: {
+        signDoc: StdSignDoc;
+        eip712: any;
+    }): Promise<AminoSignResponse>;
+};
+export type MagicMetadata = {
+    apiKey?: string;
+    rpcEndpoint?: string;
+};
+export type PrivateKeyMetadata = {
+    privateKey: string;
+};
+export type WalletConnectMetadata = {
+    projectId?: string;
+};
+export interface WalletStrategyEvmOptions {
+    evmChainId: EvmChainId;
+    rpcUrl?: string;
+    rpcUrls?: Partial<Record<EvmChainId, string>>;
+}
+export interface SendTransactionOptions {
+    address: string;
+    chainId: ChainId;
+    txTimeout?: number;
+    endpoints: {
+        rest: string;
+        grpc: string;
+        tm?: string;
+    };
+}
+export declare const TurnkeyProvider: {
+    readonly Email: "email";
+    readonly Google: "google";
+    readonly Apple: "apple";
+};
+export type TurnkeyProvider = (typeof TurnkeyProvider)[keyof typeof TurnkeyProvider];
+export type TurnkeySession = {
+    sessionType: any;
+    userId: string;
+    organizationId: string;
+    expiry: number;
+    token: string;
+};
+export interface TurnkeyMetadata {
+    apiBaseUrl: string;
+    otpInitPath?: string;
+    otpVerifyPath?: string;
+    googleClientId?: string;
+    oauthLoginPath?: string;
+    session?: TurnkeySession;
+    apiServerEndpoint: string;
+    credentialBundle?: string;
+    googleRedirectUri?: string;
+    expirationSeconds?: string;
+    defaultOrganizationId: string;
+}
+export interface WalletMetadata {
+    magic?: MagicMetadata;
+    turnkey?: Partial<TurnkeyMetadata>;
+    walletConnect?: WalletConnectMetadata;
+    privateKey?: PrivateKeyMetadata;
+}
+export interface ConcreteWalletStrategyArgs {
+    chainId: ChainId;
+    metadata?: WalletMetadata;
+}
+export interface ConcreteEvmWalletStrategyArgs extends ConcreteWalletStrategyArgs {
+    evmOptions: WalletStrategyEvmOptions;
+}
+export interface ConcreteCosmosWalletStrategyArgs extends ConcreteWalletStrategyArgs {
+    wallet?: Wallet;
+}
+export interface ConcreteCosmosWalletStrategy {
+    metadata?: WalletMetadata;
+    setMetadata?(metadata?: WalletMetadata): void;
+    /**
+     * The accounts from the wallet (addresses)
+     */
+    getAddresses(args?: unknown): Promise<string[]>;
+    /**
+     * Return the WalletDeviceType connected on the
+     * wallet provider (extension, mobile, hardware wallet)
+     */
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    /**
+     * Get the PubKey from the wallet
+     * in base64 for Cosmos native wallets
+     */
+    getPubKey(address?: string): Promise<string>;
+    /**
+     * Perform validations and checks
+     * for the wallet (if the chain is supported, etc)
+     */
+    enable(args?: unknown): Promise<boolean>;
+    /**
+     * Sends Cosmos transaction. Returns a transaction hash
+     * @param transaction should implement TransactionConfig
+     * @param options
+     */
+    sendTransaction(transaction: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+    signCosmosTransaction(transaction: {
+        txRaw: TxRaw;
+        chainId: string;
+        accountNumber: number;
+        address: string;
+    }): Promise<DirectSignResponse>;
+    signAminoTransaction(transaction: {
+        stdSignDoc: StdSignDoc;
+        address: string;
+    }): Promise<AminoSignResponse>;
+}
+export type ConcreteStrategiesArg = {
+    [key in Wallet]?: ConcreteWalletStrategy;
+};
+export interface WalletStrategyArguments {
+    chainId: ChainId;
+    metadata?: WalletMetadata;
+    evmOptions?: WalletStrategyEvmOptions;
+    disabledWallets?: Wallet[];
+    wallet?: Wallet;
+    strategies: ConcreteStrategiesArg;
+}
+export interface ConcreteWalletStrategy extends Omit<ConcreteCosmosWalletStrategy, 'sendTransaction' | 'isChainIdSupported' | 'signAminoTransaction'> {
+    /**
+     * Sends Cosmos transaction. Returns a transaction hash
+     * @param transaction should implement TransactionConfig
+     * @param options
+     */
+    sendTransaction(transaction: DirectSignResponse | TxRaw, options: {
+        address: string;
+        chainId: ChainId;
+        txTimeout?: number;
+        endpoints?: {
+            rest: string;
+            grpc: string;
+            tm?: string;
+        };
+    }): Promise<TxResponse>;
+    /**
+     * Confirm the address on the wallet
+     * @param address address
+     */
+    getSessionOrConfirm(address?: string): Promise<string>;
+    /**
+     * Sends Ethereum transaction. Returns a transaction hash
+     * @param transaction should implement TransactionConfig
+     * @param options
+     */
+    sendEvmTransaction(transaction: unknown, options: {
+        address: string;
+        evmChainId: EvmChainId;
+    }): Promise<string>;
+    /**
+     * Sign a cosmos transaction using the wallet provider
+     *
+     * @param transaction
+     * @param address - injective address
+     */
+    signCosmosTransaction(transaction: {
+        txRaw: TxRaw;
+        accountNumber: number;
+        chainId: string;
+        address: string;
+    }): Promise<DirectSignResponse>;
+    /**
+     * Sign an amino sign doc using the wallet provider
+     *
+     * @param transaction
+     * @param address - injective address
+     */
+    signAminoCosmosTransaction(transaction: {
+        signDoc: StdSignDoc;
+        address: string;
+    }): Promise<AminoSignResponse>;
+    /**
+     * Sign EIP712 TypedData using the wallet provider
+     * @param eip712TypedData
+     * @param address - ethereum address
+     */
+    signEip712TypedData(eip712TypedData: string, address: string, options?: {
+        txTimeout?: number;
+    }): Promise<string>;
+    signArbitrary(signer: string, data: string | Uint8Array): Promise<string>;
+    getEthereumChainId(): Promise<string>;
+    getEvmTransactionReceipt(txHash: string, evmChainId?: EvmChainId): void;
+    onAccountChange?(callback: onAccountChangeCallback): Promise<void> | void;
+    onChainIdChange?(callback: onChainIdChangeCallback): Promise<void> | void;
+    disconnect?(): Promise<void> | void;
+    getCosmosWallet?(chainId: ChainId): CosmosWalletAbstraction;
+    getWalletClient?<T>(): Promise<T>;
+    getEip1193Provider?(): Promise<Eip1193Provider>;
+    getOfflineSigner?(chainId: string): Promise<OfflineSigner>;
+}
+export interface WalletStrategy {
+    strategies: ConcreteStrategiesArg;
+    wallet: Wallet;
+    args: WalletStrategyArguments;
+    metadata?: WalletMetadata;
+    getWallet(): Wallet;
+    getWalletClient?<T>(): Promise<T>;
+    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>;
+    sendTransaction(tx: DirectSignResponse | TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+    sendEvmTransaction(tx: any, options: {
+        address: AccountAddress;
+        evmChainId: EvmChainId;
+    }): 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>;
+}
+export type { StdSignDoc };

package/dist/esm/types/strategy.js

@@ -0,0 +1,5 @@
+export const TurnkeyProvider = {
+    Email: 'email',
+    Google: 'google',
+    Apple: 'apple',
+};

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

@@ -0,0 +1,2 @@
+export declare const getInjectiveSignerAddress: (address: string | undefined) => string;
+export declare const getEthereumSignerAddress: (address: string | undefined) => string;

package/dist/esm/utils/address.js

@@ -0,0 +1,25 @@
+import { getEthereumAddress, getInjectiveAddress } from '@injectivelabs/sdk-ts';
+export const getInjectiveSignerAddress = (address) => {
+    if (!address) {
+        return '';
+    }
+    if (address.startsWith('inj')) {
+        return address;
+    }
+    if (address.startsWith('0x')) {
+        return getInjectiveAddress(address);
+    }
+    return '';
+};
+export const getEthereumSignerAddress = (address) => {
+    if (!address) {
+        return '';
+    }
+    if (address.startsWith('0x')) {
+        return address;
+    }
+    if (address.startsWith('inj')) {
+        return getEthereumAddress(address);
+    }
+    return '';
+};

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

@@ -0,0 +1 @@
+export declare const getKeyFromRpcUrl: (rpcUrl: string) => string;

package/dist/esm/utils/alchemy.js

@@ -0,0 +1,7 @@
+export const getKeyFromRpcUrl = (rpcUrl) => {
+    if (!rpcUrl.includes('alchemyapi.io') && !rpcUrl.includes('alchemy.com')) {
+        return rpcUrl;
+    }
+    const [key] = rpcUrl.split('/').reverse();
+    return key;
+};

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

@@ -0,0 +1,6 @@
+import type { BigNumber } from '@injectivelabs/utils';
+export declare const GWEI_IN_WEI: BigNumber;
+export declare const TIP_IN_GWEI: BigNumber;
+export declare const DEFAULT_BASE_DERIVATION_PATH = "m/44'/60'";
+export declare const DEFAULT_NUM_ADDRESSES_TO_FETCH = 5;
+export declare const DEFAULT_ADDRESS_SEARCH_LIMIT = 100;

package/dist/esm/utils/constants.js

@@ -0,0 +1,6 @@
+import { toBigNumber } from '@injectivelabs/utils';
+export const GWEI_IN_WEI = toBigNumber(1000000000);
+export const TIP_IN_GWEI = toBigNumber(2).times(GWEI_IN_WEI);
+export const DEFAULT_BASE_DERIVATION_PATH = "m/44'/60'";
+export const DEFAULT_NUM_ADDRESSES_TO_FETCH = 5;
+export const DEFAULT_ADDRESS_SEARCH_LIMIT = 100;

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

@@ -0,0 +1,2 @@
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/sdk-ts';
+export declare const createCosmosSignDocFromSignDoc: (signDoc: CosmosTxV1Beta1Tx.SignDoc) => any;

package/dist/esm/utils/cosmos.js

@@ -0,0 +1,9 @@
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/sdk-ts';
+export const createCosmosSignDocFromSignDoc = (signDoc) => {
+    return CosmosTxV1Beta1Tx.SignDoc.fromPartial({
+        bodyBytes: signDoc.bodyBytes,
+        authInfoBytes: signDoc.authInfoBytes,
+        accountNumber: BigInt(signDoc.accountNumber).toString(),
+        chainId: signDoc.chainId,
+    });
+};

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

@@ -0,0 +1,6 @@
+export * from './address.js';
+export * from './tx.js';
+export * from './wallet.js';
+export * from './constants.js';
+export * from './alchemy.js';
+export * from './cosmos.js';

package/dist/esm/utils/index.js

@@ -0,0 +1,6 @@
+export * from './address.js';
+export * from './tx.js';
+export * from './wallet.js';
+export * from './constants.js';
+export * from './alchemy.js';
+export * from './cosmos.js';

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

@@ -0,0 +1,31 @@
+import type { Msgs } from '@injectivelabs/sdk-ts';
+import type { ChainId } from '@injectivelabs/ts-types';
+export declare const createEip712StdSignDoc: ({ memo, chainId, accountNumber, timeoutHeight, sequence, gas, msgs, }: {
+    memo?: string;
+    chainId: ChainId;
+    timeoutHeight?: string;
+    accountNumber: number;
+    sequence: number;
+    gas?: string;
+    msgs: Msgs[];
+}) => {
+    chain_id: ChainId;
+    timeout_height: string;
+    account_number: string;
+    sequence: string;
+    fee: {
+        amount: {
+            denom: string;
+            amount: string;
+        }[];
+        gas: string;
+        payer: string | undefined;
+        granter: string | undefined;
+        feePayer: string | undefined;
+    };
+    msgs: {
+        type: string;
+        value: any;
+    }[];
+    memo: string;
+};

package/dist/esm/utils/tx.js

@@ -0,0 +1,10 @@
+import { getStdFee } from '@injectivelabs/utils';
+export const createEip712StdSignDoc = ({ memo, chainId, accountNumber, timeoutHeight, sequence, gas, msgs, }) => ({
+    chain_id: chainId,
+    timeout_height: timeoutHeight || '',
+    account_number: accountNumber.toString(),
+    sequence: sequence.toString(),
+    fee: getStdFee({ gas }),
+    msgs: msgs.map((m) => m.toEip712()),
+    memo: memo || '',
+});

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

@@ -0,0 +1,7 @@
+import { Wallet } from './../types/enums.js';
+export declare const isEvmWallet: (wallet: Wallet) => boolean;
+export declare const isCosmosWallet: (wallet: Wallet) => boolean;
+export declare const isEvmBrowserWallet: (wallet: Wallet) => boolean;
+export declare const isCosmosBrowserWallet: (wallet: Wallet) => boolean;
+export declare const isEip712V2OnlyWallet: (wallet: Wallet) => boolean;
+export declare const isCosmosAminoOnlyWallet: (wallet: Wallet) => boolean;

package/dist/esm/utils/wallet.js

@@ -0,0 +1,43 @@
+import { Wallet } from './../types/enums.js';
+export const isEvmWallet = (wallet) => [
+    Wallet.Magic,
+    Wallet.Rabby,
+    Wallet.BitGet,
+    Wallet.Ledger,
+    Wallet.Phantom,
+    Wallet.Rainbow,
+    Wallet.Turnkey,
+    Wallet.Metamask,
+    Wallet.OkxWallet,
+    Wallet.PrivateKey,
+    Wallet.TrezorBip32,
+    Wallet.TrezorBip44,
+    Wallet.TrustWallet,
+    Wallet.LedgerLegacy,
+    Wallet.WalletConnect,
+    Wallet.CosmostationEth,
+].includes(wallet);
+export const isCosmosWallet = (wallet) => !isEvmWallet(wallet);
+export const isEvmBrowserWallet = (wallet) => [
+    Wallet.Rabby,
+    Wallet.BitGet,
+    Wallet.Phantom,
+    Wallet.Rainbow,
+    Wallet.Metamask,
+    Wallet.OkxWallet,
+    Wallet.TrustWallet,
+].includes(wallet);
+export const isCosmosBrowserWallet = (wallet) => [
+    Wallet.Leap,
+    Wallet.Keplr,
+    Wallet.Ninji,
+    Wallet.OWallet,
+    Wallet.Cosmostation,
+].includes(wallet);
+export const isEip712V2OnlyWallet = (wallet) => [
+    Wallet.Magic,
+    Wallet.Phantom,
+    Wallet.Metamask,
+    Wallet.WalletConnect,
+].includes(wallet);
+export const isCosmosAminoOnlyWallet = (wallet) => [Wallet.LedgerCosmos].includes(wallet);