@injectivelabs/sdk-ts 1.16.37 → 1.16.38-alpha.0

package/dist/esm/core/tx/api/TxGrpcApi.d.ts

@@ -1,30 +0,0 @@
-import { CosmosTxV1Beta1Service, CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
-import type { TxResponse } from '../types/tx.js';
-import type { grpcPkg } from '../../../utils/grpc.js';
-import type { TxConcreteApi, TxClientBroadcastOptions, TxClientBroadcastResponse } from '../types/tx.js';
-export declare class TxGrpcApi implements TxConcreteApi {
-    txService: CosmosTxV1Beta1Service.ServiceClientImpl;
-    protected metadata?: grpcPkg.grpc.Metadata;
-    endpoint: string;
-    constructor(endpoint: string);
-    setMetadata(map: Record<string, string>): this;
-    clearMetadata(): void;
-    fetchTx(hash: string): Promise<TxResponse>;
-    fetchTxPoll(txHash: string, timeout?: number): Promise<TxResponse>;
-    simulate(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<{
-        result: {
-            data: string | Uint8Array<ArrayBufferLike>;
-            log: string;
-            eventsList: import("@injectivelabs/core-proto-ts/cjs/cometbft/abci/v1/types.js").Event[];
-            events?: import("@injectivelabs/core-proto-ts/cjs/cometbft/abci/v1/types.js").Event[] | undefined;
-            msgResponses?: import("@injectivelabs/core-proto-ts/cjs/google/protobuf/any.js").Any[] | undefined;
-        };
-        gasInfo: {
-            gasWanted: number;
-            gasUsed: number;
-        };
-    }>;
-    broadcast(txRaw: CosmosTxV1Beta1Tx.TxRaw, options?: TxClientBroadcastOptions): Promise<TxResponse>;
-    /** @deprecated - the BLOCk mode broadcasting is deprecated now, use either sync or async */
-    broadcastBlock(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<TxClientBroadcastResponse>;
-}

package/dist/esm/core/tx/api/TxGrpcApi.js

@@ -1,199 +0,0 @@
-import { CosmosTxV1Beta1Service, CosmosTxV1Beta1Tx, } from '@injectivelabs/core-proto-ts';
-import { GeneralException, TransactionException, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
-import { toBigNumber, DEFAULT_BLOCK_TIME_IN_SECONDS, DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, } from '@injectivelabs/utils';
-import { grpc } from '../../../utils/grpc.js';
-import BaseGrpcWebConsumer from '../../../client/base/BaseGrpcWebConsumer.js';
-export class TxGrpcApi {
-    txService;
-    metadata;
-    endpoint;
-    constructor(endpoint) {
-        this.endpoint = endpoint;
-        this.txService = new CosmosTxV1Beta1Service.ServiceClientImpl(BaseGrpcWebConsumer.getGrpcWebImpl(endpoint));
-    }
-    setMetadata(map) {
-        const metadata = new grpc.Metadata();
-        Object.keys(map).forEach((key) => metadata.set(key, map[key]));
-        this.metadata = metadata;
-        return this;
-    }
-    clearMetadata() {
-        this.metadata = undefined;
-    }
-    async fetchTx(hash) {
-        const request = CosmosTxV1Beta1Service.GetTxRequest.create();
-        request.hash = hash;
-        try {
-            const response = await this.txService.GetTx(request, this.metadata);
-            const txResponse = response.txResponse;
-            if (!txResponse) {
-                throw new GrpcUnaryRequestException(new Error(`The transaction with ${hash} is not found`), {
-                    context: 'TxGrpcApi',
-                    contextModule: 'fetch-tx',
-                });
-            }
-            if (txResponse.code !== 0) {
-                throw new TransactionException(new Error(txResponse.rawLog), {
-                    contextCode: txResponse.code,
-                    contextModule: txResponse.codespace,
-                });
-            }
-            return {
-                ...txResponse,
-                height: parseInt(txResponse.height, 10),
-                gasWanted: parseInt(txResponse.gasWanted, 10),
-                gasUsed: parseInt(txResponse.gasUsed, 10),
-                txHash: txResponse.txhash,
-            };
-        }
-        catch (e) {
-            // Transaction has failed on the chain
-            if (e instanceof TransactionException) {
-                throw e;
-            }
-            // Failed to query the transaction on the chain
-            if (e instanceof CosmosTxV1Beta1Service.GrpcWebError) {
-                throw new GrpcUnaryRequestException(new Error(e.toString()), {
-                    code: grpcErrorCodeToErrorCode(e.code),
-                });
-            }
-            // The response itself failed
-            throw new GrpcUnaryRequestException(new Error('There was an issue while fetching transaction details'), {
-                context: 'TxGrpcApi',
-                contextModule: 'fetch-tx',
-            });
-        }
-    }
-    async fetchTxPoll(txHash, timeout = DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS) {
-        const POLL_INTERVAL = DEFAULT_BLOCK_TIME_IN_SECONDS * 1000;
-        for (let i = 0; i <= timeout / POLL_INTERVAL; i += 1) {
-            try {
-                const txResponse = await this.fetchTx(txHash);
-                if (txResponse) {
-                    return txResponse;
-                }
-            }
-            catch (e) {
-                // We throw only if the transaction failed on chain
-                if (e instanceof TransactionException) {
-                    throw e;
-                }
-            }
-            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
-        }
-        // Transaction was not included in the block in the desired timeout
-        throw new GrpcUnaryRequestException(new Error(`Transaction was not included in a block before timeout of ${timeout}ms`), {
-            context: 'TxGrpcApi',
-            contextModule: 'fetch-tx-poll',
-        });
-    }
-    async simulate(txRaw) {
-        const { txService } = this;
-        const txRawClone = CosmosTxV1Beta1Tx.TxRaw.fromPartial({ ...txRaw });
-        const simulateRequest = CosmosTxV1Beta1Service.SimulateRequest.create();
-        if (txRawClone.signatures.length === 0) {
-            txRawClone.signatures = [new Uint8Array(0)];
-        }
-        simulateRequest.txBytes =
-            CosmosTxV1Beta1Tx.TxRaw.encode(txRawClone).finish();
-        try {
-            const response = await txService.Simulate(simulateRequest, this.metadata);
-            const result = {
-                ...response.result,
-                data: response.result ? response.result.data : '',
-                log: response.result ? response.result.log : '',
-                eventsList: response.result ? response.result.events : [],
-            };
-            const gasInfo = {
-                ...response.gasInfo,
-                gasWanted: response.gasInfo
-                    ? parseInt(response.gasInfo.gasWanted, 10)
-                    : 0,
-                gasUsed: response.gasInfo ? parseInt(response.gasInfo.gasUsed, 10) : 0,
-            };
-            return {
-                result: result,
-                gasInfo: gasInfo,
-            };
-        }
-        catch (e) {
-            throw new TransactionException(e, {
-                context: 'TxGrpcApi.simulate',
-                skipParsing: true,
-            });
-        }
-    }
-    async broadcast(txRaw, options) {
-        const { txService } = this;
-        const mode = options?.mode || CosmosTxV1Beta1Service.BroadcastMode.BROADCAST_MODE_SYNC;
-        const timeout = options?.timeout ||
-            toBigNumber(options?.txTimeout || DEFAULT_BLOCK_TIMEOUT_HEIGHT)
-                .times(DEFAULT_BLOCK_TIME_IN_SECONDS * 1000)
-                .toNumber();
-        const broadcastTxRequest = CosmosTxV1Beta1Service.BroadcastTxRequest.create();
-        broadcastTxRequest.txBytes = CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish();
-        broadcastTxRequest.mode = mode;
-        try {
-            const response = await txService.BroadcastTx(broadcastTxRequest, this.metadata);
-            const txResponse = response.txResponse;
-            if (!txResponse) {
-                throw new GrpcUnaryRequestException(new Error(`The transaction has failed to be broadcasted`), {
-                    context: 'TxGrpcApi.broadcast',
-                    contextModule: 'broadcast',
-                });
-            }
-            if (txResponse.code !== 0) {
-                throw new TransactionException(new Error(txResponse.rawLog), {
-                    contextCode: txResponse.code,
-                    contextModule: txResponse.codespace,
-                });
-            }
-            const result = await this.fetchTxPoll(txResponse.txhash, timeout);
-            return result;
-        }
-        catch (e) {
-            if (e instanceof TransactionException) {
-                throw e;
-            }
-            if (e instanceof GrpcUnaryRequestException) {
-                throw e;
-            }
-            throw new TransactionException(new Error(e));
-        }
-    }
-    /** @deprecated - the BLOCk mode broadcasting is deprecated now, use either sync or async */
-    async broadcastBlock(txRaw) {
-        const { txService } = this;
-        const broadcastTxRequest = CosmosTxV1Beta1Service.BroadcastTxRequest.create();
-        broadcastTxRequest.txBytes = CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish();
-        broadcastTxRequest.mode =
-            CosmosTxV1Beta1Service.BroadcastMode.BROADCAST_MODE_BLOCK;
-        try {
-            const response = await txService.BroadcastTx(broadcastTxRequest, this.metadata);
-            const txResponse = response.txResponse;
-            if (!txResponse) {
-                throw new GeneralException(new Error('There was an issue broadcasting the transaction'));
-            }
-            const result = {
-                ...txResponse,
-                height: parseInt(txResponse.height, 10),
-                gasWanted: parseInt(txResponse.gasWanted, 10),
-                gasUsed: parseInt(txResponse.gasUsed, 10),
-                txHash: txResponse.txhash,
-            };
-            if (result.code !== 0) {
-                throw new TransactionException(new Error(result.rawLog), {
-                    contextCode: result.code,
-                    contextModule: result.codespace,
-                });
-            }
-            return result;
-        }
-        catch (e) {
-            if (e instanceof TransactionException) {
-                throw e;
-            }
-            throw new TransactionException(new Error(e));
-        }
-    }
-}

package/dist/esm/core/tx/api/TxRestApi.d.ts

@@ -1,55 +0,0 @@
-import { CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
-import { HttpClient } from '@injectivelabs/utils';
-import type { TxResponse } from '../types/tx.js';
-import type { TxClientBroadcastOptions, TxConcreteApi } from '../types/tx.js';
-/**
- * It is recommended to use TxGrpcClient instead of TxRestApi
- */
-export declare class TxRestApi implements TxConcreteApi {
-    httpClient: HttpClient;
-    constructor(endpoint: string, options?: {
-        timeout?: number;
-    });
-    fetchTx(txHash: string, params?: any): Promise<TxResponse>;
-    fetchTxPoll(txHash: string, timeout?: number): Promise<TxResponse>;
-    simulate(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<{
-        result: {
-            data: string;
-            log: string;
-            eventsList: {
-                type: string;
-                attributes: {
-                    key: string;
-                    value: string;
-                }[];
-            }[];
-        };
-        gasInfo: {
-            gasWanted: number;
-            gasUsed: number;
-        };
-    }>;
-    broadcast(tx: CosmosTxV1Beta1Tx.TxRaw, options?: TxClientBroadcastOptions): Promise<TxResponse>;
-    /**
-     * Broadcast the transaction using the "block" mode, waiting for its inclusion in the blockchain.
-     * @param tx transaction to broadcast
-     *
-     * @deprecated - the BLOCk mode broadcasting is deprecated now, use either sync or async
-     */
-    broadcastBlock(tx: CosmosTxV1Beta1Tx.TxRaw): Promise<{
-        txHash: string;
-        rawLog: string;
-        gasWanted: number;
-        gasUsed: number;
-        height: number;
-        logs: import("../types/tx-rest-client.js").RestTxLog[];
-        code: number;
-        codespace: string;
-        data: string;
-        info: string;
-        timestamp: string;
-    }>;
-    private broadcastTx;
-    private getRaw;
-    private postRaw;
-}

package/dist/esm/core/tx/api/TxRestApi.js

@@ -1,239 +0,0 @@
-import axios from 'axios';
-import { StatusCodes } from 'http-status-codes';
-import { CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
-import { HttpRequestMethod, HttpRequestException, TransactionException, UnspecifiedErrorCode, } from '@injectivelabs/exceptions';
-import { HttpClient, toBigNumber, DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_BLOCK_TIME_IN_SECONDS, DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, } from '@injectivelabs/utils';
-import { TxClient } from '../utils/classes/TxClient.js';
-import { BroadcastMode } from '../types/tx-rest-client.js';
-import { getErrorMessage } from '../../../utils/helpers.js';
-/**
- * It is recommended to use TxGrpcClient instead of TxRestApi
- */
-export class TxRestApi {
-    httpClient;
-    constructor(endpoint, options) {
-        this.httpClient = new HttpClient(endpoint, {
-            headers: {
-                Accept: 'application/json',
-            },
-            timeout: options?.timeout || 15000,
-        });
-    }
-    async fetchTx(txHash, params = {}) {
-        try {
-            const response = await this.getRaw(`/cosmos/tx/v1beta1/txs/${txHash}`, params);
-            const { tx_response: txResponse } = response;
-            if (!txResponse) {
-                throw new HttpRequestException(new Error(`The transaction with ${txHash} is not found`), {
-                    context: `/cosmos/tx/v1beta1/txs/${txHash}`,
-                    contextModule: 'TxRestApi.fetch-tx',
-                });
-            }
-            if (parseInt(txResponse.code.toString(), 10) !== 0) {
-                throw new TransactionException(new Error(txResponse.raw_log), {
-                    contextCode: txResponse.code,
-                    contextModule: txResponse.codespace,
-                });
-            }
-            return {
-                ...txResponse,
-                rawLog: txResponse.raw_log,
-                gasWanted: parseInt(txResponse.gas_wanted, 10),
-                gasUsed: parseInt(txResponse.gas_used, 10),
-                height: parseInt(txResponse.height, 10),
-                txHash: txResponse.txhash,
-            };
-        }
-        catch (e) {
-            // Transaction has failed on the chain
-            if (e instanceof TransactionException) {
-                throw e;
-            }
-            // Failed to query the transaction on the chain
-            if (e instanceof HttpRequestException) {
-                throw e;
-            }
-            // The response itself failed
-            throw new HttpRequestException(new Error('There was an issue while fetching transaction details'), {
-                context: `/cosmos/tx/v1beta1/txs/${txHash}`,
-                contextModule: 'TxRestApi.fetch-tx',
-            });
-        }
-    }
-    async fetchTxPoll(txHash, timeout = DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS || 60000) {
-        const POLL_INTERVAL = DEFAULT_BLOCK_TIME_IN_SECONDS * 1000;
-        for (let i = 0; i <= timeout / POLL_INTERVAL; i += 1) {
-            try {
-                const txInfo = await this.fetchTx(txHash);
-                const txResponse = txInfo;
-                if (txResponse) {
-                    return txResponse;
-                }
-            }
-            catch (e) {
-                // We throw only if the transaction failed on chain
-                if (e instanceof TransactionException) {
-                    throw e;
-                }
-            }
-            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
-        }
-        throw new HttpRequestException(new Error(`Transaction was not included in a block before timeout of ${timeout}ms`), {
-            context: `/cosmos/tx/v1beta1/txs/${txHash}`,
-            contextModule: 'TxRestApi.fetch-tx-poll',
-        });
-    }
-    async simulate(txRaw) {
-        const txRawClone = CosmosTxV1Beta1Tx.TxRaw.fromPartial({ ...txRaw });
-        if (txRawClone.signatures.length === 0) {
-            txRawClone.signatures = [new Uint8Array(0)];
-        }
-        try {
-            const response = await this.postRaw('/cosmos/tx/v1beta1/simulate', {
-                tx_bytes: TxClient.encode(txRawClone),
-            });
-            return {
-                result: {
-                    data: response.result.data,
-                    log: response.result.log,
-                    eventsList: response.result.events,
-                },
-                gasInfo: {
-                    gasWanted: parseInt(response.gas_info.gas_wanted, 10),
-                    gasUsed: parseInt(response.gas_info.gas_used, 10),
-                },
-            };
-        }
-        catch (e) {
-            throw new TransactionException(new Error(e));
-        }
-    }
-    async broadcast(tx, options) {
-        const timeout = options?.timeout ||
-            toBigNumber(options?.txTimeout || DEFAULT_BLOCK_TIMEOUT_HEIGHT)
-                .times(DEFAULT_BLOCK_TIME_IN_SECONDS * 1000)
-                .toNumber();
-        try {
-            const { tx_response: txResponse } = await this.broadcastTx(tx, BroadcastMode.Sync);
-            if (!txResponse) {
-                throw new HttpRequestException(new Error('The transaction has failed to be broadcasted'), {
-                    context: 'TxRestApi.broadcast',
-                    contextModule: 'broadcast',
-                });
-            }
-            if (txResponse.code !== 0) {
-                throw new TransactionException(new Error(txResponse.raw_log), {
-                    contextCode: txResponse.code,
-                    contextModule: txResponse.codespace,
-                });
-            }
-            return this.fetchTxPoll(txResponse.txhash, timeout);
-        }
-        catch (e) {
-            if (e instanceof HttpRequestException) {
-                if (e.code !== StatusCodes.OK) {
-                    throw e;
-                }
-            }
-            throw e;
-        }
-    }
-    /**
-     * Broadcast the transaction using the "block" mode, waiting for its inclusion in the blockchain.
-     * @param tx transaction to broadcast
-     *
-     * @deprecated - the BLOCk mode broadcasting is deprecated now, use either sync or async
-     */
-    async broadcastBlock(tx) {
-        const response = await this.broadcastTx(tx, BroadcastMode.Block);
-        try {
-            const { tx_response: txResponse } = response;
-            if (txResponse.code !== 0) {
-                throw new TransactionException(new Error(txResponse.raw_log), {
-                    contextCode: txResponse.code,
-                    contextModule: txResponse.codespace,
-                });
-            }
-            return {
-                txHash: txResponse.txhash,
-                rawLog: txResponse.raw_log,
-                gasWanted: parseInt(txResponse.gas_wanted || '0', 10),
-                gasUsed: parseInt(txResponse.gas_used || '0', 10),
-                height: parseInt(txResponse.height || '0', 10),
-                logs: txResponse.logs || [],
-                code: txResponse.code,
-                codespace: txResponse.codespace,
-                data: txResponse.data,
-                info: txResponse.info,
-                timestamp: txResponse.timestamp || '0',
-            };
-        }
-        catch (e) {
-            if (e instanceof TransactionException) {
-                throw e;
-            }
-            throw new TransactionException(new Error(e));
-        }
-    }
-    async broadcastTx(txRaw, mode = BroadcastMode.Sync) {
-        const response = await this.postRaw('cosmos/tx/v1beta1/txs', {
-            tx_bytes: TxClient.encode(txRaw),
-            mode,
-        });
-        return response;
-    }
-    async getRaw(endpoint, params = {}) {
-        try {
-            return await this.httpClient
-                .get(endpoint, params)
-                .then((d) => d.data);
-        }
-        catch (e) {
-            const error = e;
-            if (axios.isAxiosError(error)) {
-                if (error.code === 'ECONNABORTED') {
-                    throw new HttpRequestException(new Error(error.message), {
-                        code: StatusCodes.REQUEST_TOO_LONG,
-                        context: endpoint,
-                    });
-                }
-                const message = getErrorMessage(error, endpoint);
-                throw new HttpRequestException(new Error(message), {
-                    context: endpoint,
-                    code: error.response
-                        ? error.response.status
-                        : StatusCodes.BAD_REQUEST,
-                });
-            }
-            throw new HttpRequestException(new Error(error.message), {
-                context: endpoint,
-                code: UnspecifiedErrorCode,
-            });
-        }
-    }
-    async postRaw(endpoint, params = {}) {
-        try {
-            return await this.httpClient
-                .post(endpoint, params)
-                .then((d) => d.data);
-        }
-        catch (e) {
-            const error = e;
-            if (axios.isAxiosError(error)) {
-                const message = getErrorMessage(error, endpoint);
-                throw new HttpRequestException(new Error(message), {
-                    code: error.response
-                        ? error.response.status
-                        : StatusCodes.BAD_REQUEST,
-                    context: endpoint,
-                    contextModule: HttpRequestMethod.Post,
-                });
-            }
-            throw new HttpRequestException(new Error(error.message), {
-                code: UnspecifiedErrorCode,
-                context: endpoint,
-                contextModule: HttpRequestMethod.Post,
-            });
-        }
-    }
-}

package/dist/esm/core/tx/api/index.d.ts

@@ -1,3 +0,0 @@
-export * from './TxGrpcApi.js';
-export * from './TxRestApi.js';
-export * from './utils.js';

package/dist/esm/core/tx/api/index.js

@@ -1,3 +0,0 @@
-export * from './TxGrpcApi.js';
-export * from './TxRestApi.js';
-export * from './utils.js';

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

@@ -1,8 +0,0 @@
-import type { TxResponse } from '../types/index.js';
-export declare const waitTxBroadcasted: (txHash: string, options: {
-    endpoints: {
-        grpc?: string;
-        rest: string;
-    };
-    txTimeout?: number;
-}) => Promise<TxResponse>;

package/dist/esm/core/tx/api/utils.js

@@ -1,11 +0,0 @@
-import { toBigNumber, DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_BLOCK_TIME_IN_SECONDS, } from '@injectivelabs/utils';
-import { TxGrpcApi } from './TxGrpcApi.js';
-import { TxRestApi } from './TxRestApi.js';
-export const waitTxBroadcasted = (txHash, options) => {
-    const timeout = toBigNumber(options?.txTimeout || DEFAULT_BLOCK_TIMEOUT_HEIGHT)
-        .times(DEFAULT_BLOCK_TIME_IN_SECONDS * 1000)
-        .toNumber();
-    return options.endpoints.grpc
-        ? new TxGrpcApi(options.endpoints.grpc).fetchTxPoll(txHash, timeout)
-        : new TxRestApi(options.endpoints.rest).fetchTxPoll(txHash, timeout);
-};

package/dist/esm/core/tx/arbitrary.d.ts

@@ -1,21 +0,0 @@
-export declare const generateArbitrarySignDoc: (message: string, signer: string) => {
-    signDoc: {
-        account_number: string;
-        chain_id: string;
-        fee: {
-            amount: never[];
-            gas: string;
-        };
-        memo: string;
-        msgs: {
-            type: string;
-            value: {
-                data: string;
-                signer: string;
-            };
-        }[];
-        sequence: string;
-    };
-    signDocBuff: Buffer<ArrayBuffer>;
-    stringifiedSignDoc: string;
-};

package/dist/esm/core/tx/arbitrary.js

@@ -1,29 +0,0 @@
-import { toUtf8 } from '../../utils/utf8.js';
-import { sortObjectByKeys } from '../../utils/helpers.js';
-export const generateArbitrarySignDoc = (message, signer) => {
-    const signDoc = {
-        account_number: '0',
-        chain_id: '',
-        fee: {
-            amount: [],
-            gas: '0',
-        },
-        memo: '',
-        msgs: [
-            {
-                type: 'sign/MsgSignData',
-                value: {
-                    data: Buffer.from(toUtf8(message)).toString('base64'),
-                    signer: signer,
-                },
-            },
-        ],
-        sequence: '0',
-    };
-    const stringified = toUtf8(JSON.stringify(sortObjectByKeys(signDoc)));
-    return {
-        signDoc,
-        signDocBuff: Buffer.from(stringified),
-        stringifiedSignDoc: stringified,
-    };
-};