carbon-js-sdk 0.3.53-dev.1 → 0.3.53-dev.2

package/lib/codec/cosmos/tx/v1beta1/tx.js

@@ -618,13 +618,13 @@ exports.ModeInfo_Single = {
         const message = Object.assign({}, baseModeInfo_Single);
         message.mode =
             object.mode !== undefined && object.mode !== null
-                ? signing_1.signModeFromJSON(object.mode)
+                ? (0, signing_1.signModeFromJSON)(object.mode)
                 : 0;
         return message;
     },
     toJSON(message) {
         const obj = {};
-        message.mode !== undefined && (obj.mode = signing_1.signModeToJSON(message.mode));
+        message.mode !== undefined && (obj.mode = (0, signing_1.signModeToJSON)(message.mode));
         return obj;
     },
     fromPartial(object) {

package/lib/codec/ethermint/crypto/v1/ethsecp256k1/keys.d.ts

@@ -0,0 +1,39 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "ethermint.crypto.v1.ethsecp256k1";
+/**
+ * PubKey defines a type alias for an ecdsa.PublicKey that implements
+ * Tendermint's PubKey interface. It represents the 33-byte compressed public
+ * key format.
+ */
+export interface PubKey {
+    /** key is the public key in byte form */
+    key: Uint8Array;
+}
+/**
+ * PrivKey defines a type alias for an ecdsa.PrivateKey that implements
+ * Tendermint's PrivateKey interface.
+ */
+export interface PrivKey {
+    /** key is the private key in byte form */
+    key: Uint8Array;
+}
+export declare const PubKey: {
+    encode(message: PubKey, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PubKey;
+    fromJSON(object: any): PubKey;
+    toJSON(message: PubKey): unknown;
+    fromPartial(object: DeepPartial<PubKey>): PubKey;
+};
+export declare const PrivKey: {
+    encode(message: PrivKey, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PrivKey;
+    fromJSON(object: any): PrivKey;
+    toJSON(message: PrivKey): unknown;
+    fromPartial(object: DeepPartial<PrivKey>): PrivKey;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare 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/crypto/v1/ethsecp256k1/keys.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivKey = exports.PubKey = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "ethermint.crypto.v1.ethsecp256k1";
+const basePubKey = {};
+exports.PubKey = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, basePubKey);
+        message.key = new Uint8Array();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, basePubKey);
+        message.key =
+            object.key !== undefined && object.key !== null
+                ? bytesFromBase64(object.key)
+                : new Uint8Array();
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined &&
+            (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, basePubKey);
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
+        return message;
+    },
+};
+const basePrivKey = {};
+exports.PrivKey = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, basePrivKey);
+        message.key = new Uint8Array();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, basePrivKey);
+        message.key =
+            object.key !== undefined && object.key !== null
+                ? bytesFromBase64(object.key)
+                : new Uint8Array();
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined &&
+            (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, basePrivKey);
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
+        return message;
+    },
+};
+var globalThis = (() => {
+    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";
+})();
+const atob = globalThis.atob ||
+    ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
+function bytesFromBase64(b64) {
+    const bin = atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+        arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+}
+const btoa = globalThis.btoa ||
+    ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
+function base64FromBytes(arr) {
+    const bin = [];
+    for (const byte of arr) {
+        bin.push(String.fromCharCode(byte));
+    }
+    return btoa(bin.join(""));
+}
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/codec/ethermint/evm/v1/events.d.ts

@@ -0,0 +1,72 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "ethermint.evm.v1";
+/** EventEthereumTx defines the event for an Ethereum transaction */
+export interface EventEthereumTx {
+    /** amount */
+    amount: string;
+    /** eth_hash is the Ethereum hash of the transaction */
+    ethHash: string;
+    /** index of the transaction in the block */
+    index: string;
+    /** gas_used is the amount of gas used by the transaction */
+    gasUsed: string;
+    /** hash is the Tendermint hash of the transaction */
+    hash: string;
+    /** recipient of the transaction */
+    recipient: string;
+    /** eth_tx_failed contains a VM error should it occur */
+    ethTxFailed: string;
+}
+/** EventTxLog defines the event for an Ethereum transaction log */
+export interface EventTxLog {
+    /** tx_logs is an array of transaction logs */
+    txLogs: string[];
+}
+/** EventMessage */
+export interface EventMessage {
+    /** module which emits the event */
+    module: string;
+    /** sender of the message */
+    sender: string;
+    /** tx_type is the type of the message */
+    txType: string;
+}
+/** EventBlockBloom defines an Ethereum block bloom filter event */
+export interface EventBlockBloom {
+    /** bloom is the bloom filter of the block */
+    bloom: string;
+}
+export declare const EventEthereumTx: {
+    encode(message: EventEthereumTx, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): EventEthereumTx;
+    fromJSON(object: any): EventEthereumTx;
+    toJSON(message: EventEthereumTx): unknown;
+    fromPartial(object: DeepPartial<EventEthereumTx>): EventEthereumTx;
+};
+export declare const EventTxLog: {
+    encode(message: EventTxLog, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): EventTxLog;
+    fromJSON(object: any): EventTxLog;
+    toJSON(message: EventTxLog): unknown;
+    fromPartial(object: DeepPartial<EventTxLog>): EventTxLog;
+};
+export declare const EventMessage: {
+    encode(message: EventMessage, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): EventMessage;
+    fromJSON(object: any): EventMessage;
+    toJSON(message: EventMessage): unknown;
+    fromPartial(object: DeepPartial<EventMessage>): EventMessage;
+};
+export declare const EventBlockBloom: {
+    encode(message: EventBlockBloom, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): EventBlockBloom;
+    fromJSON(object: any): EventBlockBloom;
+    toJSON(message: EventBlockBloom): unknown;
+    fromPartial(object: DeepPartial<EventBlockBloom>): EventBlockBloom;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare 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/evm/v1/events.js

@@ -0,0 +1,303 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBlockBloom = exports.EventMessage = exports.EventTxLog = exports.EventEthereumTx = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "ethermint.evm.v1";
+const baseEventEthereumTx = {
+    amount: "",
+    ethHash: "",
+    index: "",
+    gasUsed: "",
+    hash: "",
+    recipient: "",
+    ethTxFailed: "",
+};
+exports.EventEthereumTx = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.amount !== "") {
+            writer.uint32(10).string(message.amount);
+        }
+        if (message.ethHash !== "") {
+            writer.uint32(18).string(message.ethHash);
+        }
+        if (message.index !== "") {
+            writer.uint32(26).string(message.index);
+        }
+        if (message.gasUsed !== "") {
+            writer.uint32(34).string(message.gasUsed);
+        }
+        if (message.hash !== "") {
+            writer.uint32(42).string(message.hash);
+        }
+        if (message.recipient !== "") {
+            writer.uint32(50).string(message.recipient);
+        }
+        if (message.ethTxFailed !== "") {
+            writer.uint32(58).string(message.ethTxFailed);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseEventEthereumTx);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.amount = reader.string();
+                    break;
+                case 2:
+                    message.ethHash = reader.string();
+                    break;
+                case 3:
+                    message.index = reader.string();
+                    break;
+                case 4:
+                    message.gasUsed = reader.string();
+                    break;
+                case 5:
+                    message.hash = reader.string();
+                    break;
+                case 6:
+                    message.recipient = reader.string();
+                    break;
+                case 7:
+                    message.ethTxFailed = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseEventEthereumTx);
+        message.amount =
+            object.amount !== undefined && object.amount !== null
+                ? String(object.amount)
+                : "";
+        message.ethHash =
+            object.ethHash !== undefined && object.ethHash !== null
+                ? String(object.ethHash)
+                : "";
+        message.index =
+            object.index !== undefined && object.index !== null
+                ? String(object.index)
+                : "";
+        message.gasUsed =
+            object.gasUsed !== undefined && object.gasUsed !== null
+                ? String(object.gasUsed)
+                : "";
+        message.hash =
+            object.hash !== undefined && object.hash !== null
+                ? String(object.hash)
+                : "";
+        message.recipient =
+            object.recipient !== undefined && object.recipient !== null
+                ? String(object.recipient)
+                : "";
+        message.ethTxFailed =
+            object.ethTxFailed !== undefined && object.ethTxFailed !== null
+                ? String(object.ethTxFailed)
+                : "";
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.amount !== undefined && (obj.amount = message.amount);
+        message.ethHash !== undefined && (obj.ethHash = message.ethHash);
+        message.index !== undefined && (obj.index = message.index);
+        message.gasUsed !== undefined && (obj.gasUsed = message.gasUsed);
+        message.hash !== undefined && (obj.hash = message.hash);
+        message.recipient !== undefined && (obj.recipient = message.recipient);
+        message.ethTxFailed !== undefined &&
+            (obj.ethTxFailed = message.ethTxFailed);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const message = Object.assign({}, baseEventEthereumTx);
+        message.amount = (_a = object.amount) !== null && _a !== void 0 ? _a : "";
+        message.ethHash = (_b = object.ethHash) !== null && _b !== void 0 ? _b : "";
+        message.index = (_c = object.index) !== null && _c !== void 0 ? _c : "";
+        message.gasUsed = (_d = object.gasUsed) !== null && _d !== void 0 ? _d : "";
+        message.hash = (_e = object.hash) !== null && _e !== void 0 ? _e : "";
+        message.recipient = (_f = object.recipient) !== null && _f !== void 0 ? _f : "";
+        message.ethTxFailed = (_g = object.ethTxFailed) !== null && _g !== void 0 ? _g : "";
+        return message;
+    },
+};
+const baseEventTxLog = { txLogs: "" };
+exports.EventTxLog = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        for (const v of message.txLogs) {
+            writer.uint32(10).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseEventTxLog);
+        message.txLogs = [];
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.txLogs.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        var _a;
+        const message = Object.assign({}, baseEventTxLog);
+        message.txLogs = ((_a = object.txLogs) !== null && _a !== void 0 ? _a : []).map((e) => String(e));
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.txLogs) {
+            obj.txLogs = message.txLogs.map((e) => e);
+        }
+        else {
+            obj.txLogs = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, baseEventTxLog);
+        message.txLogs = ((_a = object.txLogs) !== null && _a !== void 0 ? _a : []).map((e) => e);
+        return message;
+    },
+};
+const baseEventMessage = { module: "", sender: "", txType: "" };
+exports.EventMessage = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.module !== "") {
+            writer.uint32(10).string(message.module);
+        }
+        if (message.sender !== "") {
+            writer.uint32(18).string(message.sender);
+        }
+        if (message.txType !== "") {
+            writer.uint32(26).string(message.txType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseEventMessage);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.module = reader.string();
+                    break;
+                case 2:
+                    message.sender = reader.string();
+                    break;
+                case 3:
+                    message.txType = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseEventMessage);
+        message.module =
+            object.module !== undefined && object.module !== null
+                ? String(object.module)
+                : "";
+        message.sender =
+            object.sender !== undefined && object.sender !== null
+                ? String(object.sender)
+                : "";
+        message.txType =
+            object.txType !== undefined && object.txType !== null
+                ? String(object.txType)
+                : "";
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.module !== undefined && (obj.module = message.module);
+        message.sender !== undefined && (obj.sender = message.sender);
+        message.txType !== undefined && (obj.txType = message.txType);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseEventMessage);
+        message.module = (_a = object.module) !== null && _a !== void 0 ? _a : "";
+        message.sender = (_b = object.sender) !== null && _b !== void 0 ? _b : "";
+        message.txType = (_c = object.txType) !== null && _c !== void 0 ? _c : "";
+        return message;
+    },
+};
+const baseEventBlockBloom = { bloom: "" };
+exports.EventBlockBloom = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.bloom !== "") {
+            writer.uint32(10).string(message.bloom);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseEventBlockBloom);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.bloom = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseEventBlockBloom);
+        message.bloom =
+            object.bloom !== undefined && object.bloom !== null
+                ? String(object.bloom)
+                : "";
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.bloom !== undefined && (obj.bloom = message.bloom);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, baseEventBlockBloom);
+        message.bloom = (_a = object.bloom) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}