@injectivelabs/sdk-ts 1.16.38-alpha.7 → 1.16.38

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

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxGrpcApi = void 0;
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const utils_1 = require("@injectivelabs/utils");
+const grpc_js_1 = require("../../../utils/grpc.js");
+const BaseGrpcWebConsumer_js_1 = __importDefault(require("../../../client/base/BaseGrpcWebConsumer.js"));
+class TxGrpcApi {
+    txService;
+    metadata;
+    endpoint;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.txService = new core_proto_ts_1.CosmosTxV1Beta1Service.ServiceClientImpl(BaseGrpcWebConsumer_js_1.default.getGrpcWebImpl(endpoint));
+    }
+    setMetadata(map) {
+        const metadata = new grpc_js_1.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 = core_proto_ts_1.CosmosTxV1Beta1Service.GetTxRequest.create();
+        request.hash = hash;
+        try {
+            const response = await this.txService.GetTx(request, this.metadata);
+            const txResponse = response.txResponse;
+            if (!txResponse) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(`The transaction with ${hash} is not found`), {
+                    context: 'TxGrpcApi',
+                    contextModule: 'fetch-tx',
+                });
+            }
+            if (txResponse.code !== 0) {
+                throw new exceptions_1.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 exceptions_1.TransactionException) {
+                throw e;
+            }
+            // Failed to query the transaction on the chain
+            if (e instanceof core_proto_ts_1.CosmosTxV1Beta1Service.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                });
+            }
+            // The response itself failed
+            throw new exceptions_1.GrpcUnaryRequestException(new Error('There was an issue while fetching transaction details'), {
+                context: 'TxGrpcApi',
+                contextModule: 'fetch-tx',
+            });
+        }
+    }
+    async fetchTxPoll(txHash, timeout = utils_1.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS) {
+        const POLL_INTERVAL = utils_1.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 exceptions_1.TransactionException) {
+                    throw e;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+        }
+        // Transaction was not included in the block in the desired timeout
+        throw new exceptions_1.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 = core_proto_ts_1.CosmosTxV1Beta1Tx.TxRaw.fromPartial({ ...txRaw });
+        const simulateRequest = core_proto_ts_1.CosmosTxV1Beta1Service.SimulateRequest.create();
+        if (txRawClone.signatures.length === 0) {
+            txRawClone.signatures = [new Uint8Array(0)];
+        }
+        simulateRequest.txBytes =
+            core_proto_ts_1.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 exceptions_1.TransactionException(e, {
+                context: 'TxGrpcApi.simulate',
+                skipParsing: true,
+            });
+        }
+    }
+    async broadcast(txRaw, options) {
+        const { txService } = this;
+        const mode = options?.mode || core_proto_ts_1.CosmosTxV1Beta1Service.BroadcastMode.BROADCAST_MODE_SYNC;
+        const timeout = options?.timeout ||
+            (0, utils_1.toBigNumber)(options?.txTimeout || utils_1.DEFAULT_BLOCK_TIMEOUT_HEIGHT)
+                .times(utils_1.DEFAULT_BLOCK_TIME_IN_SECONDS * 1000)
+                .toNumber();
+        const broadcastTxRequest = core_proto_ts_1.CosmosTxV1Beta1Service.BroadcastTxRequest.create();
+        broadcastTxRequest.txBytes = core_proto_ts_1.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 exceptions_1.GrpcUnaryRequestException(new Error(`The transaction has failed to be broadcasted`), {
+                    context: 'TxGrpcApi.broadcast',
+                    contextModule: 'broadcast',
+                });
+            }
+            if (txResponse.code !== 0) {
+                throw new exceptions_1.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 exceptions_1.TransactionException) {
+                throw e;
+            }
+            if (e instanceof exceptions_1.GrpcUnaryRequestException) {
+                throw e;
+            }
+            throw new exceptions_1.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 = core_proto_ts_1.CosmosTxV1Beta1Service.BroadcastTxRequest.create();
+        broadcastTxRequest.txBytes = core_proto_ts_1.CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish();
+        broadcastTxRequest.mode =
+            core_proto_ts_1.CosmosTxV1Beta1Service.BroadcastMode.BROADCAST_MODE_BLOCK;
+        try {
+            const response = await txService.BroadcastTx(broadcastTxRequest, this.metadata);
+            const txResponse = response.txResponse;
+            if (!txResponse) {
+                throw new exceptions_1.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 exceptions_1.TransactionException(new Error(result.rawLog), {
+                    contextCode: result.code,
+                    contextModule: result.codespace,
+                });
+            }
+            return result;
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.TransactionException) {
+                throw e;
+            }
+            throw new exceptions_1.TransactionException(new Error(e));
+        }
+    }
+}
+exports.TxGrpcApi = TxGrpcApi;

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

@@ -0,0 +1,55 @@
+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/cjs/core/tx/api/TxRestApi.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxRestApi = void 0;
+const axios_1 = __importDefault(require("axios"));
+const http_status_codes_1 = require("http-status-codes");
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const utils_1 = require("@injectivelabs/utils");
+const TxClient_js_1 = require("../utils/classes/TxClient.js");
+const tx_rest_client_js_1 = require("../types/tx-rest-client.js");
+const helpers_js_1 = require("../../../utils/helpers.js");
+/**
+ * It is recommended to use TxGrpcClient instead of TxRestApi
+ */
+class TxRestApi {
+    httpClient;
+    constructor(endpoint, options) {
+        this.httpClient = new utils_1.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 exceptions_1.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 exceptions_1.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 exceptions_1.TransactionException) {
+                throw e;
+            }
+            // Failed to query the transaction on the chain
+            if (e instanceof exceptions_1.HttpRequestException) {
+                throw e;
+            }
+            // The response itself failed
+            throw new exceptions_1.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 = utils_1.DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS || 60000) {
+        const POLL_INTERVAL = utils_1.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 exceptions_1.TransactionException) {
+                    throw e;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+        }
+        throw new exceptions_1.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 = core_proto_ts_1.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_js_1.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 exceptions_1.TransactionException(new Error(e));
+        }
+    }
+    async broadcast(tx, options) {
+        const timeout = options?.timeout ||
+            (0, utils_1.toBigNumber)(options?.txTimeout || utils_1.DEFAULT_BLOCK_TIMEOUT_HEIGHT)
+                .times(utils_1.DEFAULT_BLOCK_TIME_IN_SECONDS * 1000)
+                .toNumber();
+        try {
+            const { tx_response: txResponse } = await this.broadcastTx(tx, tx_rest_client_js_1.BroadcastMode.Sync);
+            if (!txResponse) {
+                throw new exceptions_1.HttpRequestException(new Error('The transaction has failed to be broadcasted'), {
+                    context: 'TxRestApi.broadcast',
+                    contextModule: 'broadcast',
+                });
+            }
+            if (txResponse.code !== 0) {
+                throw new exceptions_1.TransactionException(new Error(txResponse.raw_log), {
+                    contextCode: txResponse.code,
+                    contextModule: txResponse.codespace,
+                });
+            }
+            return this.fetchTxPoll(txResponse.txhash, timeout);
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.HttpRequestException) {
+                if (e.code !== http_status_codes_1.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, tx_rest_client_js_1.BroadcastMode.Block);
+        try {
+            const { tx_response: txResponse } = response;
+            if (txResponse.code !== 0) {
+                throw new exceptions_1.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 exceptions_1.TransactionException) {
+                throw e;
+            }
+            throw new exceptions_1.TransactionException(new Error(e));
+        }
+    }
+    async broadcastTx(txRaw, mode = tx_rest_client_js_1.BroadcastMode.Sync) {
+        const response = await this.postRaw('cosmos/tx/v1beta1/txs', {
+            tx_bytes: TxClient_js_1.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_1.default.isAxiosError(error)) {
+                if (error.code === 'ECONNABORTED') {
+                    throw new exceptions_1.HttpRequestException(new Error(error.message), {
+                        code: http_status_codes_1.StatusCodes.REQUEST_TOO_LONG,
+                        context: endpoint,
+                    });
+                }
+                const message = (0, helpers_js_1.getErrorMessage)(error, endpoint);
+                throw new exceptions_1.HttpRequestException(new Error(message), {
+                    context: endpoint,
+                    code: error.response
+                        ? error.response.status
+                        : http_status_codes_1.StatusCodes.BAD_REQUEST,
+                });
+            }
+            throw new exceptions_1.HttpRequestException(new Error(error.message), {
+                context: endpoint,
+                code: exceptions_1.UnspecifiedErrorCode,
+            });
+        }
+    }
+    async postRaw(endpoint, params = {}) {
+        try {
+            return await this.httpClient
+                .post(endpoint, params)
+                .then((d) => d.data);
+        }
+        catch (e) {
+            const error = e;
+            if (axios_1.default.isAxiosError(error)) {
+                const message = (0, helpers_js_1.getErrorMessage)(error, endpoint);
+                throw new exceptions_1.HttpRequestException(new Error(message), {
+                    code: error.response
+                        ? error.response.status
+                        : http_status_codes_1.StatusCodes.BAD_REQUEST,
+                    context: endpoint,
+                    contextModule: exceptions_1.HttpRequestMethod.Post,
+                });
+            }
+            throw new exceptions_1.HttpRequestException(new Error(error.message), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: endpoint,
+                contextModule: exceptions_1.HttpRequestMethod.Post,
+            });
+        }
+    }
+}
+exports.TxRestApi = TxRestApi;

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

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

package/dist/cjs/core/tx/api/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("./TxGrpcApi.js"), exports);
+__exportStar(require("./TxRestApi.js"), exports);
+__exportStar(require("./utils.js"), exports);

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

@@ -0,0 +1,8 @@
+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/cjs/core/tx/api/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitTxBroadcasted = void 0;
+const utils_1 = require("@injectivelabs/utils");
+const TxGrpcApi_js_1 = require("./TxGrpcApi.js");
+const TxRestApi_js_1 = require("./TxRestApi.js");
+const waitTxBroadcasted = (txHash, options) => {
+    const timeout = (0, utils_1.toBigNumber)(options?.txTimeout || utils_1.DEFAULT_BLOCK_TIMEOUT_HEIGHT)
+        .times(utils_1.DEFAULT_BLOCK_TIME_IN_SECONDS * 1000)
+        .toNumber();
+    return options.endpoints.grpc
+        ? new TxGrpcApi_js_1.TxGrpcApi(options.endpoints.grpc).fetchTxPoll(txHash, timeout)
+        : new TxRestApi_js_1.TxRestApi(options.endpoints.rest).fetchTxPoll(txHash, timeout);
+};
+exports.waitTxBroadcasted = waitTxBroadcasted;

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

@@ -0,0 +1,21 @@
+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/cjs/core/tx/arbitrary.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateArbitrarySignDoc = void 0;
+const utf8_js_1 = require("../../utils/utf8.js");
+const helpers_js_1 = require("../../utils/helpers.js");
+const generateArbitrarySignDoc = (message, signer) => {
+    const signDoc = {
+        account_number: '0',
+        chain_id: '',
+        fee: {
+            amount: [],
+            gas: '0',
+        },
+        memo: '',
+        msgs: [
+            {
+                type: 'sign/MsgSignData',
+                value: {
+                    data: Buffer.from((0, utf8_js_1.toUtf8)(message)).toString('base64'),
+                    signer: signer,
+                },
+            },
+        ],
+        sequence: '0',
+    };
+    const stringified = (0, utf8_js_1.toUtf8)(JSON.stringify((0, helpers_js_1.sortObjectByKeys)(signDoc)));
+    return {
+        signDoc,
+        signDocBuff: Buffer.from(stringified),
+        stringifiedSignDoc: stringified,
+    };
+};
+exports.generateArbitrarySignDoc = generateArbitrarySignDoc;