@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/esm/client/wasm/trading_strategies/types.d.ts

@@ -0,0 +1,33 @@
+import { ExitConfig, ExitType, StrategyType, TrailingArithmetic } from '../../../core/modules/wasm/types.js';
+export type QueryTradingStrategyContractSrategyResponse = {
+    user: string;
+    subaccount_id: string;
+    info: {
+        lower_bound: string;
+        upper_bound: string;
+        levels: number;
+        prices: string[];
+    };
+    stop_loss?: ExitConfig;
+    take_profit?: ExitConfig;
+    target_value_per_order: string;
+    exit_type: ExitType;
+    order_state: {
+        buy_orders: number;
+        sell_orders: number;
+        omit_order: 'buy' | 'sell';
+    };
+    retry_count: number;
+    strategy_type: StrategyType | TrailingArithmetic;
+};
+export type QueryTradingStrategyContractConfigResponse = {
+    owner: string;
+    base_decimals: number;
+    quote_decimals: number;
+    market_id: string;
+    small_order_threshold: string;
+    maximum_order_value_deviation: string;
+    maximum_rebalance_retries: number;
+    default_slippage: string;
+    version: string;
+};

package/dist/esm/client/wasm/trading_strategies/types.js

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

package/dist/esm/client/wasm/types.d.ts

@@ -0,0 +1,3 @@
+export interface WasmContractQueryResponse {
+    data: Uint8Array;
+}

package/dist/esm/client/wasm/types.js

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

package/dist/esm/core/accounts/AccountParser.d.ts

@@ -0,0 +1,2 @@
+import { Account } from '@cosmjs/stargate';
+export declare const accountParser: (ethAccount: any) => Account;

package/dist/esm/core/accounts/AccountParser.js

@@ -0,0 +1,17 @@
+import { InjectiveTypesV1Beta1Account } from '@injectivelabs/core-proto-ts';
+export const accountParser = (ethAccount) => {
+    const account = InjectiveTypesV1Beta1Account.EthAccount.decode(ethAccount.value);
+    const baseAccount = account.baseAccount;
+    const pubKey = baseAccount.pubKey;
+    return {
+        address: baseAccount.address,
+        pubkey: pubKey
+            ? {
+                type: '/injective.crypto.v1beta1.ethsecp256k1.PubKey',
+                value: Buffer.from(pubKey.value).toString('base64'),
+            }
+            : null,
+        accountNumber: parseInt(baseAccount.accountNumber, 10),
+        sequence: parseInt(baseAccount.sequence, 10),
+    };
+};

package/dist/esm/core/accounts/AccountParserNoCosmjs.d.ts

@@ -0,0 +1 @@
+export declare const accountEthParser: <T>(ethAccount: any, pubKeyTypeUrl?: string) => T;

package/dist/esm/core/accounts/AccountParserNoCosmjs.js

@@ -0,0 +1,17 @@
+import { InjectiveTypesV1Beta1Account } from '@injectivelabs/core-proto-ts';
+export const accountEthParser = (ethAccount, pubKeyTypeUrl = '/injective.crypto.v1beta1.ethsecp256k1.PubKey') => {
+    const account = InjectiveTypesV1Beta1Account.EthAccount.decode(ethAccount.value);
+    const baseAccount = account.baseAccount;
+    const pubKey = baseAccount.pubKey;
+    return {
+        address: baseAccount.address,
+        pubkey: pubKey
+            ? {
+                type: pubKeyTypeUrl,
+                value: Buffer.from(pubKey.value).toString('base64'),
+            }
+            : null,
+        accountNumber: parseInt(baseAccount.accountNumber, 10),
+        sequence: parseInt(baseAccount.sequence, 10),
+    };
+};

package/dist/esm/core/accounts/Address.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @category Utility Classes
+ */
+export declare class Address {
+    bech32Address: string;
+    constructor(bech32Address: string);
+    compare(address: Address): boolean;
+    get address(): string;
+    /**
+     * Create an address instance from a bech32-encoded address and a prefix
+     * @param {string} bech32 bech32-encoded address
+     * @param {string} prefix
+     * @return {Address}
+     * @throws {Error} if bech is not a valid bech32-encoded address
+     */
+    static fromBech32(bech: string, prefix?: string): Address;
+    /**
+     * Create an address instance from an ethereum address
+     * @param {string} hex Ethereum address
+     * @param {string} prefix
+     * @return {Address}
+     * @throws {Error} if bech is not a valid bech32-encoded address
+     */
+    static fromHex(hex: string, prefix?: string): Address;
+    /**
+     * Convert an address instance to a bech32-encoded account address
+     * @param {string} prefix
+     * @returns {string}
+     */
+    toBech32(prefix?: string): string;
+    /**
+     * Return a bech32-encoded account address
+     * @return {string}
+     * @throws {Error} if this address is not a valid account address
+     * */
+    toAccountAddress(): string;
+    /**
+     * Return a bech32-encoded validator address
+     * @return {string}
+     * @throws {Error} if this address is not a valid validator address
+     * */
+    toValidatorAddress(): string;
+    /**
+     * Return a bech32-encoded consensus address
+     * @return {string}
+     * @throws {Error} if this address is not a valid consensus address
+     * */
+    toConsensusAddress(): string;
+    /**
+     * Return a hex representation of address
+     * @return {string}
+     * @throws {Error} if this address is not a valid account address
+     * */
+    toHex(): string;
+    /**
+     * Return a subaccount address from the given bech32 encoded address
+     * @param {number} index the subaccount index
+     * @return {string}
+     * @throws {Error} if this address is not a valid account address
+     * */
+    getSubaccountId(index?: number): string;
+    /**
+     * Return a ethereum address from the given bech32 encoded address
+     * @return {string}
+     * @throws {Error} if this address is not a valid account address
+     * */
+    getEthereumAddress(): string;
+}

package/dist/esm/core/accounts/Address.js

@@ -0,0 +1,116 @@
+import { bech32 } from 'bech32';
+import { Address as EthereumUtilsAddress } from 'ethereumjs-util';
+import { ErrorType, GeneralException } from '@injectivelabs/exceptions';
+import { BECH32_ADDR_ACC_PREFIX, BECH32_ADDR_CONS_PREFIX, BECH32_ADDR_VAL_PREFIX, } from '../../utils/constants.js';
+/**
+ * @category Utility Classes
+ */
+export class Address {
+    bech32Address;
+    constructor(bech32Address) {
+        this.bech32Address = bech32Address;
+    }
+    compare(address) {
+        return this.bech32Address === address.bech32Address;
+    }
+    get address() {
+        return this.bech32Address;
+    }
+    /**
+     * Create an address instance from a bech32-encoded address and a prefix
+     * @param {string} bech32 bech32-encoded address
+     * @param {string} prefix
+     * @return {Address}
+     * @throws {Error} if bech is not a valid bech32-encoded address
+     */
+    static fromBech32(bech, prefix = BECH32_ADDR_ACC_PREFIX) {
+        try {
+            const address = Buffer.from(bech32.fromWords(bech32.decode(bech).words)).toString('hex');
+            const addressInHex = address.startsWith('0x') ? address : `0x${address}`;
+            const addressBuffer = EthereumUtilsAddress.fromString(addressInHex.toString()).toBuffer();
+            const bech32Address = bech32.encode(prefix, bech32.toWords(addressBuffer));
+            return new Address(bech32Address);
+        }
+        catch (e) {
+            throw new GeneralException(new Error(e), {
+                type: ErrorType.ValidationError,
+            });
+        }
+    }
+    /**
+     * Create an address instance from an ethereum address
+     * @param {string} hex Ethereum address
+     * @param {string} prefix
+     * @return {Address}
+     * @throws {Error} if bech is not a valid bech32-encoded address
+     */
+    static fromHex(hex, prefix = BECH32_ADDR_ACC_PREFIX) {
+        const addressHex = hex.startsWith('0x') ? hex : `0x${hex}`;
+        const addressBuffer = EthereumUtilsAddress.fromString(addressHex.toString()).toBuffer();
+        const bech32Address = bech32.encode(prefix, bech32.toWords(addressBuffer));
+        return new Address(bech32Address);
+    }
+    /**
+     * Convert an address instance to a bech32-encoded account address
+     * @param {string} prefix
+     * @returns {string}
+     */
+    toBech32(prefix = BECH32_ADDR_ACC_PREFIX) {
+        const address = this.toHex();
+        const addressHex = address.startsWith('0x') ? address : `0x${address}`;
+        const addressBuffer = EthereumUtilsAddress.fromString(addressHex).toBuffer();
+        return bech32.encode(prefix, bech32.toWords(addressBuffer));
+    }
+    /**
+     * Return a bech32-encoded account address
+     * @return {string}
+     * @throws {Error} if this address is not a valid account address
+     * */
+    toAccountAddress() {
+        return this.toBech32(BECH32_ADDR_ACC_PREFIX);
+    }
+    /**
+     * Return a bech32-encoded validator address
+     * @return {string}
+     * @throws {Error} if this address is not a valid validator address
+     * */
+    toValidatorAddress() {
+        return this.toBech32(BECH32_ADDR_VAL_PREFIX);
+    }
+    /**
+     * Return a bech32-encoded consensus address
+     * @return {string}
+     * @throws {Error} if this address is not a valid consensus address
+     * */
+    toConsensusAddress() {
+        return this.toBech32(BECH32_ADDR_CONS_PREFIX);
+    }
+    /**
+     * Return a hex representation of address
+     * @return {string}
+     * @throws {Error} if this address is not a valid account address
+     * */
+    toHex() {
+        const { bech32Address } = this;
+        const address = Buffer.from(bech32.fromWords(bech32.decode(bech32Address).words)).toString('hex');
+        return address.startsWith('0x') ? address : `0x${address}`;
+    }
+    /**
+     * Return a subaccount address from the given bech32 encoded address
+     * @param {number} index the subaccount index
+     * @return {string}
+     * @throws {Error} if this address is not a valid account address
+     * */
+    getSubaccountId(index = 0) {
+        const suffix = '0'.repeat(23) + index; /* TODO for double digit numbers */
+        return `${this.toHex()}${suffix}`;
+    }
+    /**
+     * Return a ethereum address from the given bech32 encoded address
+     * @return {string}
+     * @throws {Error} if this address is not a valid account address
+     * */
+    getEthereumAddress() {
+        return this.toHex();
+    }
+}

package/dist/esm/core/accounts/BaseAccount.d.ts

@@ -0,0 +1,27 @@
+import { Address } from './Address.js';
+import { AccountResponse, BaseAccountRestResponse } from '../../client/chain/index.js';
+import { AccountDetails } from '../../types/auth.js';
+/**
+ * @category Utility Classes
+ */
+export declare class BaseAccount extends Address {
+    accountNumber: number;
+    sequence: number;
+    pubKey: {
+        type: string;
+        key: string;
+    };
+    constructor({ address, accountNumber, sequence, pubKey, }: {
+        address: string;
+        accountNumber: number;
+        sequence: number;
+        pubKey: {
+            type: string;
+            key: string;
+        };
+    });
+    static fromRestApi(accountResponse: AccountResponse): BaseAccount;
+    static fromRestCosmosApi(accountResponse: BaseAccountRestResponse): BaseAccount;
+    incrementSequence(): this;
+    toAccountDetails(): AccountDetails;
+}

package/dist/esm/core/accounts/BaseAccount.js

@@ -0,0 +1,66 @@
+import { Address } from './Address.js';
+/**
+ * @category Utility Classes
+ */
+export class BaseAccount extends Address {
+    accountNumber;
+    sequence;
+    pubKey;
+    constructor({ address, accountNumber, sequence, pubKey, }) {
+        super(address);
+        this.accountNumber = accountNumber;
+        this.sequence = sequence;
+        this.pubKey = pubKey;
+    }
+    static fromRestApi(accountResponse) {
+        const { base_account: baseAccount } = accountResponse.account;
+        return new BaseAccount({
+            address: baseAccount.address,
+            accountNumber: baseAccount.account_number
+                ? parseInt(baseAccount.account_number, 10)
+                : 0,
+            sequence: baseAccount.sequence ? parseInt(baseAccount.sequence, 10) : 0,
+            pubKey: baseAccount.pub_key
+                ? {
+                    type: baseAccount.pub_key['@type'],
+                    key: baseAccount.pub_key.key,
+                }
+                : {
+                    type: '',
+                    key: '',
+                },
+        });
+    }
+    static fromRestCosmosApi(accountResponse) {
+        return new BaseAccount({
+            address: accountResponse.address,
+            accountNumber: accountResponse.account_number
+                ? parseInt(accountResponse.account_number, 10)
+                : 0,
+            sequence: accountResponse.sequence
+                ? parseInt(accountResponse.sequence, 10)
+                : 0,
+            pubKey: accountResponse.pub_key
+                ? {
+                    type: accountResponse.pub_key['@type'],
+                    key: accountResponse.pub_key.key,
+                }
+                : {
+                    type: '',
+                    key: '',
+                },
+        });
+    }
+    incrementSequence() {
+        this.sequence += 1;
+        return this;
+    }
+    toAccountDetails() {
+        return {
+            pubKey: this.pubKey,
+            sequence: this.sequence,
+            address: this.bech32Address,
+            accountNumber: this.accountNumber,
+        };
+    }
+}

package/dist/esm/core/accounts/PrivateKey.d.ts

@@ -0,0 +1,166 @@
+import { PublicKey } from './PublicKey.js';
+import { Address } from './Address.js';
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+/**
+ * Class for wrapping SigningKey that is used for signature creation and public key derivation.
+ *
+ * @category Crypto Utility Classes
+ */
+export declare class PrivateKey {
+    private wallet;
+    private constructor();
+    /**
+     * Generate new private key with random mnemonic phrase
+     * @returns { privateKey: PrivateKey, mnemonic: string }
+     */
+    static generate(): {
+        privateKey: PrivateKey;
+        mnemonic: string;
+    };
+    /**
+     * Create a PrivateKey instance from a given mnemonic phrase and a HD derivation path.
+     * If path is not given, default to Band's HD prefix 494 and all other indexes being zeroes.
+     * @param {string} words the mnemonic phrase
+     * @param {string|undefined} path the HD path that follows the BIP32 standard (optional)
+     * @returns {PrivateKey} Initialized PrivateKey object
+     */
+    static fromMnemonic(words: string, path?: string): PrivateKey;
+    /**
+     * Create a PrivateKey instance from a given private key and a HD derivation path.
+     * If path is not given, default to Band's HD prefix 494 and all other indexes being zeroes.
+     * @param {string} privateKey  the private key
+     * @returns {PrivateKey} Initialized PrivateKey object
+     *
+     * @deprecated - use fromHex instead
+     */
+    static fromPrivateKey(privateKey: string): PrivateKey;
+    /**
+     * Create a PrivateKey instance from a given private key and a HD derivation path.
+     * If path is not given, default to Band's HD prefix 494 and all other indexes being zeroes.
+     * @param {string} privateKey  the private key
+     * @returns {PrivateKey} Initialized PrivateKey object
+     */
+    static fromHex(privateKey: string | Uint8Array): PrivateKey;
+    /**
+     * Return the private key in hex
+     * @returns {string}
+     **/
+    toPrivateKeyHex(): string;
+    /**
+     * Return the PublicKey associated with this private key.
+     * @returns {PublicKey} a Public key that can be used to verify the signatures made with this PrivateKey
+     **/
+    toPublicKey(): PublicKey;
+    /**
+     * Return the hex address associated with this private key.
+     * @returns {string}
+     */
+    toHex(): string;
+    /**
+     * Return the Address associated with this private key.
+     * @returns {Address}
+     **/
+    toAddress(): Address;
+    /**
+     * Return the Bech32 address associated with this private key.
+     * @returns {string}
+     **/
+    toBech32(): string;
+    /**
+     * Sign the given message using the wallet's _signingKey function.
+     * @param {string} messageBytes: the message that will be hashed and signed, a Buffer made of bytes
+     * @returns {Uint8Array} a signature of this private key over the given message
+     */
+    sign(messageBytes: Buffer): Uint8Array;
+    /**
+     * Sign the given message using the edcsa sign_deterministic function.
+     * @param {Buffer} messageBytes: the message that will be hashed and signed, a Buffer made of bytes
+     * @returns {Uint8Array} a signature of this private key over the given message
+     */
+    signEcda(messageBytes: Buffer): Uint8Array;
+    /**
+     * Sign the given message using the wallet's _signingKey function.
+     * @param {string} messageHashedBytes: the message that will be signed, a Buffer made of bytes
+     * @returns {Uint8Array} a signature of this private key over the given message
+     */
+    signHashed(messageHashedBytes: Buffer): Uint8Array;
+    /**
+     * Sign the given message using the edcsa sign_deterministic function.
+     * @param {Buffer} messageHashedBytes: the message that will be signed, a Buffer made of bytes
+     * @returns {Uint8Array} a signature of this private key over the given message
+     */
+    signHashedEcda(messageHashedBytes: Buffer): Uint8Array;
+    /**
+     * Sign the given typed data using the edcsa sign_deterministic function.
+     * @param {Buffer} eip712Data: the typed data that will be hashed and signed, a Buffer made of bytes
+     * @returns {Uint8Array} a signature of this private key over the given message
+     */
+    signTypedData(eip712Data: any): Uint8Array;
+    /**
+     * Sign the given typed data using the edcsa sign_deterministic function.
+     * @param {Buffer} eip712Data: the typed data that will be signed, a Buffer made of bytes
+     * @returns {Uint8Array} a signature of this private key over the given message
+     */
+    signHashedTypedData(eip712Data: Buffer): Uint8Array;
+    /**
+     * Verify signature using EIP712 typed data
+     * and the publicKey
+     *
+     * (params are passed as an object)
+     *
+     * @param {string} signature: the signature to verify in hex
+     * @param {any} eip712: the EIP712 typed data to verify against
+     * @param {string} publicKey: the public key to verify against in hex
+     * */
+    static verifySignature({ signature, eip712, publicKey, }: {
+        signature: string;
+        eip712: any;
+        publicKey: string;
+    }): boolean;
+    /**
+     * Verify signature using EIP712 typed data
+     * and the publicKey
+     *
+     * (params are passed as an object)
+     *
+     * @param {string} signature: the signature to verify in hex
+     * @param {any} eip712: the EIP712 typed data to verify against
+     * @param {string} publicKey: the public key to verify against in hex
+     * */
+    verifyThisPkSignature({ signature, eip712, }: {
+        signature: string;
+        eip712: any;
+    }): boolean;
+    /**
+     * Verify cosmos signature EIP712 typed
+     * data from the TxRaw and verify the signature
+     * that's included in the TxRaw
+     *
+     * (params are passed as an object)
+     *
+     * @param {CosmosTxV1Beta1Tx.TxRaw} txRaw: the signature to verify in hex
+     * @param {object} signer: the public key and the account number to verify against
+     **/
+    static verifyCosmosSignature({ txRaw, signer, }: {
+        txRaw: CosmosTxV1Beta1Tx.TxRaw;
+        signer: {
+            accountNumber: number | string;
+            publicKey: string;
+        };
+    }): boolean;
+    /**
+     * Verify signature using ADR-36 sign doc
+     * and the publicKey
+     *
+     * (params are passed as an object)
+     *
+     * @param {string} signature: the signature to verify in hex
+     * @param {any} signDoc: the signDoc to verify against
+     * @param {string} publicKey:the public key to verify against in hex
+     * */
+    static verifyArbitrarySignature({ signature, signDoc, publicKey, }: {
+        signature: string;
+        signDoc: Buffer;
+        publicKey: string;
+    }): boolean;
+}