example-js-sdk 0.0.1

package/lib/codec/ethermint/types/v1/export.d.ts

@@ -0,0 +1,4 @@
+export { EthAccount } from "./account";
+export { ExtensionOptionDynamicFeeTx } from "./dynamic_fee";
+export { TxResult } from "./indexer";
+export { ExtensionOptionsWeb3Tx } from "./web3";

package/lib/codec/ethermint/types/v1/export.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionOptionsWeb3Tx = exports.TxResult = exports.ExtensionOptionDynamicFeeTx = exports.EthAccount = void 0;
+var account_1 = require("./account");
+Object.defineProperty(exports, "EthAccount", { enumerable: true, get: function () { return account_1.EthAccount; } });
+var dynamic_fee_1 = require("./dynamic_fee");
+Object.defineProperty(exports, "ExtensionOptionDynamicFeeTx", { enumerable: true, get: function () { return dynamic_fee_1.ExtensionOptionDynamicFeeTx; } });
+var indexer_1 = require("./indexer");
+Object.defineProperty(exports, "TxResult", { enumerable: true, get: function () { return indexer_1.TxResult; } });
+var web3_1 = require("./web3");
+Object.defineProperty(exports, "ExtensionOptionsWeb3Tx", { enumerable: true, get: function () { return web3_1.ExtensionOptionsWeb3Tx; } });

package/lib/codec/ethermint/types/v1/indexer.d.ts

@@ -0,0 +1,42 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "ethermint.types.v1";
+/** TxResult is the value stored in eth tx indexer */
+export interface TxResult {
+    /** height of the blockchain */
+    height: Long;
+    /** tx_index of the cosmos transaction */
+    txIndex: number;
+    /** msg_index in a batch transaction */
+    msgIndex: number;
+    /**
+     * eth_tx_index is the index in the list of valid eth tx in the block,
+     * aka. the transaction list returned by eth_getBlock api.
+     */
+    ethTxIndex: number;
+    /** failed is true if the eth transaction did not go succeed */
+    failed: boolean;
+    /**
+     * gas_used by the transaction. If it exceeds the block gas limit,
+     * it's set to gas limit, which is what's actually deducted by ante handler.
+     */
+    gasUsed: Long;
+    /**
+     * cumulative_gas_used specifies the cumulated amount of gas used for all
+     * processed messages within the current batch transaction.
+     */
+    cumulativeGasUsed: Long;
+}
+export declare const TxResult: {
+    encode(message: TxResult, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TxResult;
+    fromJSON(object: any): TxResult;
+    toJSON(message: TxResult): unknown;
+    create(base?: DeepPartial<TxResult>): TxResult;
+    fromPartial(object: DeepPartial<TxResult>): TxResult;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/ethermint/types/v1/indexer.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxResult = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "ethermint.types.v1";
+function createBaseTxResult() {
+    return {
+        height: long_1.default.ZERO,
+        txIndex: 0,
+        msgIndex: 0,
+        ethTxIndex: 0,
+        failed: false,
+        gasUsed: long_1.default.UZERO,
+        cumulativeGasUsed: long_1.default.UZERO,
+    };
+}
+exports.TxResult = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (!message.height.isZero()) {
+            writer.uint32(8).int64(message.height);
+        }
+        if (message.txIndex !== 0) {
+            writer.uint32(16).uint32(message.txIndex);
+        }
+        if (message.msgIndex !== 0) {
+            writer.uint32(24).uint32(message.msgIndex);
+        }
+        if (message.ethTxIndex !== 0) {
+            writer.uint32(32).int32(message.ethTxIndex);
+        }
+        if (message.failed === true) {
+            writer.uint32(40).bool(message.failed);
+        }
+        if (!message.gasUsed.isZero()) {
+            writer.uint32(48).uint64(message.gasUsed);
+        }
+        if (!message.cumulativeGasUsed.isZero()) {
+            writer.uint32(56).uint64(message.cumulativeGasUsed);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTxResult();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.height = reader.int64();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.txIndex = reader.uint32();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.msgIndex = reader.uint32();
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.ethTxIndex = reader.int32();
+                    continue;
+                case 5:
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.failed = reader.bool();
+                    continue;
+                case 6:
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.gasUsed = reader.uint64();
+                    continue;
+                case 7:
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.cumulativeGasUsed = reader.uint64();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            height: isSet(object.height) ? long_1.default.fromValue(object.height) : long_1.default.ZERO,
+            txIndex: isSet(object.txIndex) ? Number(object.txIndex) : 0,
+            msgIndex: isSet(object.msgIndex) ? Number(object.msgIndex) : 0,
+            ethTxIndex: isSet(object.ethTxIndex) ? Number(object.ethTxIndex) : 0,
+            failed: isSet(object.failed) ? Boolean(object.failed) : false,
+            gasUsed: isSet(object.gasUsed) ? long_1.default.fromValue(object.gasUsed) : long_1.default.UZERO,
+            cumulativeGasUsed: isSet(object.cumulativeGasUsed) ? long_1.default.fromValue(object.cumulativeGasUsed) : long_1.default.UZERO,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.height !== undefined && (obj.height = (message.height || long_1.default.ZERO).toString());
+        message.txIndex !== undefined && (obj.txIndex = Math.round(message.txIndex));
+        message.msgIndex !== undefined && (obj.msgIndex = Math.round(message.msgIndex));
+        message.ethTxIndex !== undefined && (obj.ethTxIndex = Math.round(message.ethTxIndex));
+        message.failed !== undefined && (obj.failed = message.failed);
+        message.gasUsed !== undefined && (obj.gasUsed = (message.gasUsed || long_1.default.UZERO).toString());
+        message.cumulativeGasUsed !== undefined &&
+            (obj.cumulativeGasUsed = (message.cumulativeGasUsed || long_1.default.UZERO).toString());
+        return obj;
+    },
+    create(base) {
+        return exports.TxResult.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTxResult();
+        message.height = (object.height !== undefined && object.height !== null)
+            ? long_1.default.fromValue(object.height)
+            : long_1.default.ZERO;
+        message.txIndex = object.txIndex ?? 0;
+        message.msgIndex = object.msgIndex ?? 0;
+        message.ethTxIndex = object.ethTxIndex ?? 0;
+        message.failed = object.failed ?? false;
+        message.gasUsed = (object.gasUsed !== undefined && object.gasUsed !== null)
+            ? long_1.default.fromValue(object.gasUsed)
+            : long_1.default.UZERO;
+        message.cumulativeGasUsed = (object.cumulativeGasUsed !== undefined && object.cumulativeGasUsed !== null)
+            ? long_1.default.fromValue(object.cumulativeGasUsed)
+            : long_1.default.UZERO;
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/lib/codec/ethermint/types/v1/web3.d.ts

@@ -0,0 +1,37 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "ethermint.types.v1";
+/**
+ * ExtensionOptionsWeb3Tx is an extension option that specifies the typed chain id,
+ * the fee payer as well as its signature data.
+ */
+export interface ExtensionOptionsWeb3Tx {
+    /**
+     * typed_data_chain_id is used only in EIP712 Domain and should match
+     * Ethereum network ID in a Web3 provider (e.g. Metamask).
+     */
+    typedDataChainId: Long;
+    /**
+     * fee_payer is an account address for the fee payer. It will be validated
+     * during EIP712 signature checking.
+     */
+    feePayer: string;
+    /**
+     * fee_payer_sig is a signature data from the fee paying account,
+     * allows to perform fee delegation when using EIP712 Domain.
+     */
+    feePayerSig: Uint8Array;
+}
+export declare const ExtensionOptionsWeb3Tx: {
+    encode(message: ExtensionOptionsWeb3Tx, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ExtensionOptionsWeb3Tx;
+    fromJSON(object: any): ExtensionOptionsWeb3Tx;
+    toJSON(message: ExtensionOptionsWeb3Tx): unknown;
+    create(base?: DeepPartial<ExtensionOptionsWeb3Tx>): ExtensionOptionsWeb3Tx;
+    fromPartial(object: DeepPartial<ExtensionOptionsWeb3Tx>): ExtensionOptionsWeb3Tx;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/ethermint/types/v1/web3.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionOptionsWeb3Tx = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "ethermint.types.v1";
+function createBaseExtensionOptionsWeb3Tx() {
+    return { typedDataChainId: long_1.default.UZERO, feePayer: "", feePayerSig: new Uint8Array() };
+}
+exports.ExtensionOptionsWeb3Tx = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (!message.typedDataChainId.isZero()) {
+            writer.uint32(8).uint64(message.typedDataChainId);
+        }
+        if (message.feePayer !== "") {
+            writer.uint32(18).string(message.feePayer);
+        }
+        if (message.feePayerSig.length !== 0) {
+            writer.uint32(26).bytes(message.feePayerSig);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExtensionOptionsWeb3Tx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.typedDataChainId = reader.uint64();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.feePayer = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.feePayerSig = reader.bytes();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            typedDataChainId: isSet(object.typedDataChainId) ? long_1.default.fromValue(object.typedDataChainId) : long_1.default.UZERO,
+            feePayer: isSet(object.feePayer) ? String(object.feePayer) : "",
+            feePayerSig: isSet(object.feePayerSig) ? bytesFromBase64(object.feePayerSig) : new Uint8Array(),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.typedDataChainId !== undefined &&
+            (obj.typedDataChainId = (message.typedDataChainId || long_1.default.UZERO).toString());
+        message.feePayer !== undefined && (obj.feePayer = message.feePayer);
+        message.feePayerSig !== undefined &&
+            (obj.feePayerSig = base64FromBytes(message.feePayerSig !== undefined ? message.feePayerSig : new Uint8Array()));
+        return obj;
+    },
+    create(base) {
+        return exports.ExtensionOptionsWeb3Tx.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseExtensionOptionsWeb3Tx();
+        message.typedDataChainId = (object.typedDataChainId !== undefined && object.typedDataChainId !== null)
+            ? long_1.default.fromValue(object.typedDataChainId)
+            : long_1.default.UZERO;
+        message.feePayer = object.feePayer ?? "";
+        message.feePayerSig = object.feePayerSig ?? new Uint8Array();
+        return message;
+    },
+};
+var tsProtoGlobalThis = (() => {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    throw "Unable to locate global object";
+})();
+function bytesFromBase64(b64) {
+    if (tsProtoGlobalThis.Buffer) {
+        return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = tsProtoGlobalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (tsProtoGlobalThis.Buffer) {
+        return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(String.fromCharCode(byte));
+        });
+        return tsProtoGlobalThis.btoa(bin.join(""));
+    }
+}
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/lib/codec/ethermint-models.d.ts

@@ -0,0 +1,4 @@
+export * as Crypto from "./ethermint/crypto/v1/ethsecp256k1/export";
+export * as Evm from "./ethermint/evm/v1/export";
+export * as Feemarket from "./ethermint/feemarket/v1/export";
+export * as Types from "./ethermint/types/v1/export";

package/lib/codec/ethermint-models.js

@@ -0,0 +1,40 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Types = exports.Feemarket = exports.Evm = exports.Crypto = void 0;
+exports.Crypto = __importStar(require("./ethermint/crypto/v1/ethsecp256k1/export"));
+exports.Evm = __importStar(require("./ethermint/evm/v1/export"));
+exports.Feemarket = __importStar(require("./ethermint/feemarket/v1/export"));
+exports.Types = __importStar(require("./ethermint/types/v1/export"));

package/lib/codec/google/protobuf/any.d.ts

@@ -0,0 +1,138 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * `Any` contains an arbitrary serialized protocol buffer message along with a
+ * URL that describes the type of the serialized message.
+ *
+ * Protobuf library provides support to pack/unpack Any values in the form
+ * of utility functions or additional generated methods of the Any type.
+ *
+ * Example 1: Pack and unpack a message in C++.
+ *
+ *     Foo foo = ...;
+ *     Any any;
+ *     any.PackFrom(foo);
+ *     ...
+ *     if (any.UnpackTo(&foo)) {
+ *       ...
+ *     }
+ *
+ * Example 2: Pack and unpack a message in Java.
+ *
+ *     Foo foo = ...;
+ *     Any any = Any.pack(foo);
+ *     ...
+ *     if (any.is(Foo.class)) {
+ *       foo = any.unpack(Foo.class);
+ *     }
+ *     // or ...
+ *     if (any.isSameTypeAs(Foo.getDefaultInstance())) {
+ *       foo = any.unpack(Foo.getDefaultInstance());
+ *     }
+ *
+ *  Example 3: Pack and unpack a message in Python.
+ *
+ *     foo = Foo(...)
+ *     any = Any()
+ *     any.Pack(foo)
+ *     ...
+ *     if any.Is(Foo.DESCRIPTOR):
+ *       any.Unpack(foo)
+ *       ...
+ *
+ *  Example 4: Pack and unpack a message in Go
+ *
+ *      foo := &pb.Foo{...}
+ *      any, err := anypb.New(foo)
+ *      if err != nil {
+ *        ...
+ *      }
+ *      ...
+ *      foo := &pb.Foo{}
+ *      if err := any.UnmarshalTo(foo); err != nil {
+ *        ...
+ *      }
+ *
+ * The pack methods provided by protobuf library will by default use
+ * 'type.googleapis.com/full.type.name' as the type URL and the unpack
+ * methods only use the fully qualified type name after the last '/'
+ * in the type URL, for example "foo.bar.com/x/y.z" will yield type
+ * name "y.z".
+ *
+ * JSON
+ * ====
+ * The JSON representation of an `Any` value uses the regular
+ * representation of the deserialized, embedded message, with an
+ * additional field `@type` which contains the type URL. Example:
+ *
+ *     package google.profile;
+ *     message Person {
+ *       string first_name = 1;
+ *       string last_name = 2;
+ *     }
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.profile.Person",
+ *       "firstName": <string>,
+ *       "lastName": <string>
+ *     }
+ *
+ * If the embedded message type is well-known and has a custom JSON
+ * representation, that representation will be embedded adding a field
+ * `value` which holds the custom JSON in addition to the `@type`
+ * field. Example (for message [google.protobuf.Duration][]):
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.protobuf.Duration",
+ *       "value": "1.212s"
+ *     }
+ */
+export interface Any {
+    /**
+     * A URL/resource name that uniquely identifies the type of the serialized
+     * protocol buffer message. This string must contain at least
+     * one "/" character. The last segment of the URL's path must represent
+     * the fully qualified name of the type (as in
+     * `path/google.protobuf.Duration`). The name should be in a canonical form
+     * (e.g., leading "." is not accepted).
+     *
+     * In practice, teams usually precompile into the binary all types that they
+     * expect it to use in the context of Any. However, for URLs which use the
+     * scheme `http`, `https`, or no scheme, one can optionally set up a type
+     * server that maps type URLs to message definitions as follows:
+     *
+     * * If no scheme is provided, `https` is assumed.
+     * * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+     *   value in binary format, or produce an error.
+     * * Applications are allowed to cache lookup results based on the
+     *   URL, or have them precompiled into a binary to avoid any
+     *   lookup. Therefore, binary compatibility needs to be preserved
+     *   on changes to types. (Use versioned type names to manage
+     *   breaking changes.)
+     *
+     * Note: this functionality is not currently available in the official
+     * protobuf release, and it is not used for type URLs beginning with
+     * type.googleapis.com. As of May 2023, there are no widely used type server
+     * implementations and no plans to implement one.
+     *
+     * Schemes other than `http`, `https` (or the empty scheme) might be
+     * used with implementation specific semantics.
+     */
+    typeUrl: string;
+    /** Must be a valid serialized protocol buffer of the above specified type. */
+    value: Uint8Array;
+}
+export declare const Any: {
+    encode(message: Any, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Any;
+    fromJSON(object: any): Any;
+    toJSON(message: Any): unknown;
+    create(base?: DeepPartial<Any>): Any;
+    fromPartial(object: DeepPartial<Any>): Any;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};