carbon-js-sdk 0.3.47 → 0.3.49

package/lib/clients/EvmIbcClient.d.ts

@@ -0,0 +1,86 @@
+import { Network } from "../constant";
+import { StdSignDoc } from "@cosmjs/amino";
+import { BlockchainUtils } from "../util";
+declare type SupportedBlockchains = BlockchainUtils.Blockchain.Canto | BlockchainUtils.Blockchain.Evmos;
+declare namespace EvmIbcClient {
+    interface TypedDomain {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+        salt: string;
+    }
+    interface TypedDataV4 {
+        types: object;
+        primaryType: string;
+        message: StdSignDoc;
+        domain: TypedDomain;
+    }
+    const TYPED_DATA_REQUEST_METHOD = "eth_signTypedData_v4";
+    const DEFAULT_EIP712_TYPES: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        Tx: {
+            name: string;
+            type: string;
+        }[];
+        Fee: {
+            name: string;
+            type: string;
+        }[];
+        Coin: {
+            name: string;
+            type: string;
+        }[];
+        Msg: {
+            name: string;
+            type: string;
+        }[];
+    };
+    const getEvmChainId: (blockchain: SupportedBlockchains, network?: Network) => 7700 | 9001;
+    const getIbcTransferTypes: () => {
+        MsgValue: {
+            name: string;
+            type: string;
+        }[];
+        TypeToken: {
+            name: string;
+            type: string;
+        }[];
+        TypeTimeoutHeight: {
+            name: string;
+            type: string;
+        }[];
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        Tx: {
+            name: string;
+            type: string;
+        }[];
+        Fee: {
+            name: string;
+            type: string;
+        }[];
+        Coin: {
+            name: string;
+            type: string;
+        }[];
+        Msg: {
+            name: string;
+            type: string;
+        }[];
+    };
+    const getCosmosWeb3Domain: (blockchain: SupportedBlockchains) => {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+        salt: string;
+    };
+    const getEIP712TypedData: (tx: StdSignDoc, blockchain: SupportedBlockchains, types?: object, domain?: EvmIbcClient.TypedDomain, primaryType?: string) => TypedDataV4;
+}
+export default EvmIbcClient;

package/lib/clients/EvmIbcClient.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("../constant");
+const util_1 = require("../util");
+const _DEFAULT_EIP712_TYPES = {
+    EIP712Domain: [
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'verifyingContract', type: 'string' },
+        { name: 'salt', type: 'string' },
+    ],
+    Tx: [
+        { name: 'account_number', type: 'string' },
+        { name: 'chain_id', type: 'string' },
+        { name: 'fee', type: 'Fee' },
+        { name: 'memo', type: 'string' },
+        { name: 'msgs', type: 'Msg[]' },
+        { name: 'sequence', type: 'string' },
+    ],
+    Fee: [
+        { name: 'feePayer', type: 'string' },
+        { name: 'amount', type: 'Coin[]' },
+        { name: 'gas', type: 'string' },
+    ],
+    Coin: [
+        { name: 'denom', type: 'string' },
+        { name: 'amount', type: 'string' },
+    ],
+    Msg: [
+        { name: 'type', type: 'string' },
+        { name: 'value', type: 'MsgValue' },
+    ],
+};
+var EvmIbcClient;
+(function (EvmIbcClient) {
+    EvmIbcClient.TYPED_DATA_REQUEST_METHOD = "eth_signTypedData_v4";
+    EvmIbcClient.DEFAULT_EIP712_TYPES = _DEFAULT_EIP712_TYPES;
+    EvmIbcClient.getEvmChainId = (blockchain, network = constant_1.Network.MainNet) => {
+        switch (network) {
+            case constant_1.Network.MainNet:
+                switch (blockchain) {
+                    case util_1.BlockchainUtils.Blockchain.Canto:
+                        return 7700;
+                    case util_1.BlockchainUtils.Blockchain.Evmos:
+                        return 9001;
+                    default:
+                        throw new Error("network not supported");
+                }
+            default:
+                throw new Error("network not supported");
+        }
+    };
+    EvmIbcClient.getIbcTransferTypes = () => {
+        return Object.assign(Object.assign({}, EvmIbcClient.DEFAULT_EIP712_TYPES), { MsgValue: [
+                { name: 'source_port', type: 'string' },
+                { name: 'source_channel', type: 'string' },
+                { name: 'token', type: 'TypeToken' },
+                { name: 'sender', type: 'string' },
+                { name: 'receiver', type: 'string' },
+                { name: 'timeout_height', type: 'TypeTimeoutHeight' },
+                { name: 'timeout_timestamp', type: 'uint64' },
+            ], TypeToken: [
+                { name: 'denom', type: 'string' },
+                { name: 'amount', type: 'string' },
+            ], TypeTimeoutHeight: [
+                { name: 'revision_number', type: 'uint64' },
+                { name: 'revision_height', type: 'uint64' },
+            ] });
+    };
+    EvmIbcClient.getCosmosWeb3Domain = (blockchain) => {
+        return {
+            name: "Cosmos Web3",
+            version: "1.0.0",
+            chainId: EvmIbcClient.getEvmChainId(blockchain),
+            verifyingContract: "cosmos",
+            salt: "0",
+        };
+    };
+    EvmIbcClient.getEIP712TypedData = (tx, blockchain, types = EvmIbcClient.getIbcTransferTypes(), domain = EvmIbcClient.getCosmosWeb3Domain(blockchain), primaryType = "Tx") => {
+        const typedData = {
+            types,
+            primaryType,
+            domain,
+            message: tx,
+        };
+        return typedData;
+    };
+})(EvmIbcClient || (EvmIbcClient = {}));
+exports.default = EvmIbcClient;

package/lib/clients/TokenClient.js

@@ -365,12 +365,12 @@ class TokenClient {
     }
     getCarbonIbcTokens() {
         const swthTokens = ibc_1.swthIbcWhitelist.map((chainId) => {
-            var _a, _b;
+            var _a, _b, _c;
             const blockchain = util_1.IBCUtils.BlockchainMap[chainId];
             const carbonBlockchain = util_1.IBCUtils.ChainIdBlockchainMap[blockchain !== null && blockchain !== void 0 ? blockchain : ""];
             const blockchainNum = (_a = util_1.BlockchainUtils.CHAIN_IDS[carbonBlockchain !== null && carbonBlockchain !== void 0 ? carbonBlockchain : ""]) !== null && _a !== void 0 ? _a : 0;
-            const swthChannel = ibc_1.swthChannels[chainId];
-            const assetDenom = util_1.IBCUtils.makeIBCMinimalDenom((_b = swthChannel.dstChannel) !== null && _b !== void 0 ? _b : "channel-0", KeplrAccount_1.default.SWTH_CURRENCY.coinMinimalDenom);
+            const swthChannel = (_b = ibc_1.swthChannels[chainId]) === null || _b === void 0 ? void 0 : _b.ibc;
+            const assetDenom = util_1.IBCUtils.makeIBCMinimalDenom((_c = swthChannel === null || swthChannel === void 0 ? void 0 : swthChannel.dstChannel) !== null && _c !== void 0 ? _c : "channel-0", KeplrAccount_1.default.SWTH_CURRENCY.coinMinimalDenom);
             return {
                 id: assetDenom,
                 creator: "",
@@ -509,8 +509,9 @@ class TokenClient {
     setCommonAssetConfig() {
         // whitelisted ibc tokens
         ibc_1.ibcWhitelist.forEach((chainId) => {
+            var _a;
             const currencies = util_1.IBCUtils.EmbedChainInfos[chainId].currencies;
-            const channelObj = ibc_1.swthChannels[chainId];
+            const channelObj = (_a = ibc_1.swthChannels[chainId]) === null || _a === void 0 ? void 0 : _a.ibc;
             currencies.forEach((asset) => {
                 var _a, _b;
                 const channel = asset.coinMinimalDenom !== "swth" ? (_a = channelObj === null || channelObj === void 0 ? void 0 : channelObj.sourceChannel) !== null && _a !== void 0 ? _a : "channel-0" : (_b = channelObj === null || channelObj === void 0 ? void 0 : channelObj.dstChannel) !== null && _b !== void 0 ? _b : "channel-0";

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/evm.d.ts

@@ -0,0 +1,239 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "ethermint.evm.v1";
+/** Params defines the EVM module parameters */
+export interface Params {
+    /**
+     * evm_denom represents the token denomination used to run the EVM state
+     * transitions.
+     */
+    evmDenom: string;
+    /** enable_create toggles state transitions that use the vm.Create function */
+    enableCreate: boolean;
+    /** enable_call toggles state transitions that use the vm.Call function */
+    enableCall: boolean;
+    /** extra_eips defines the additional EIPs for the vm.Config */
+    extraEips: Long[];
+    /** chain_config defines the EVM chain configuration parameters */
+    chainConfig?: ChainConfig;
+    /**
+     * allow_unprotected_txs defines if replay-protected (i.e non EIP155
+     * signed) transactions can be executed on the state machine.
+     */
+    allowUnprotectedTxs: boolean;
+}
+/**
+ * ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values
+ * instead of *big.Int.
+ */
+export interface ChainConfig {
+    /** homestead_block switch (nil no fork, 0 = already homestead) */
+    homesteadBlock: string;
+    /** dao_fork_block corresponds to TheDAO hard-fork switch block (nil no fork) */
+    daoForkBlock: string;
+    /** dao_fork_support defines whether the nodes supports or opposes the DAO hard-fork */
+    daoForkSupport: boolean;
+    /**
+     * eip150_block: EIP150 implements the Gas price changes
+     * (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork)
+     */
+    eip150Block: string;
+    /** eip150_hash: EIP150 HF hash (needed for header only clients as only gas pricing changed) */
+    eip150Hash: string;
+    /** eip155_block: EIP155Block HF block */
+    eip155Block: string;
+    /** eip158_block: EIP158 HF block */
+    eip158Block: string;
+    /** byzantium_block: Byzantium switch block (nil no fork, 0 = already on byzantium) */
+    byzantiumBlock: string;
+    /** constantinople_block: Constantinople switch block (nil no fork, 0 = already activated) */
+    constantinopleBlock: string;
+    /** petersburg_block: Petersburg switch block (nil same as Constantinople) */
+    petersburgBlock: string;
+    /** istanbul_block: Istanbul switch block (nil no fork, 0 = already on istanbul) */
+    istanbulBlock: string;
+    /** muir_glacier_block: Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated) */
+    muirGlacierBlock: string;
+    /** berlin_block: Berlin switch block (nil = no fork, 0 = already on berlin) */
+    berlinBlock: string;
+    /** london_block: London switch block (nil = no fork, 0 = already on london) */
+    londonBlock: string;
+    /** arrow_glacier_block: Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) */
+    arrowGlacierBlock: string;
+    /** gray_glacier_block: EIP-5133 (bomb delay) switch block (nil = no fork, 0 = already activated) */
+    grayGlacierBlock: string;
+    /** merge_netsplit_block: Virtual fork after The Merge to use as a network splitter */
+    mergeNetsplitBlock: string;
+    /** shanghai_block switch block (nil = no fork, 0 = already on shanghai) */
+    shanghaiBlock: string;
+    /** cancun_block switch block (nil = no fork, 0 = already on cancun) */
+    cancunBlock: string;
+}
+/** State represents a single Storage key value pair item. */
+export interface State {
+    /** key is the stored key */
+    key: string;
+    /** value is the stored value for the given key */
+    value: string;
+}
+/**
+ * TransactionLogs define the logs generated from a transaction execution
+ * with a given hash. It it used for import/export data as transactions are not
+ * persisted on blockchain state after an upgrade.
+ */
+export interface TransactionLogs {
+    /** hash of the transaction */
+    hash: string;
+    /** logs is an array of Logs for the given transaction hash */
+    logs: Log[];
+}
+/**
+ * Log represents an protobuf compatible Ethereum Log that defines a contract
+ * log event. These events are generated by the LOG opcode and stored/indexed by
+ * the node.
+ *
+ * NOTE: address, topics and data are consensus fields. The rest of the fields
+ * are derived, i.e. filled in by the nodes, but not secured by consensus.
+ */
+export interface Log {
+    /** address of the contract that generated the event */
+    address: string;
+    /** topics is a list of topics provided by the contract. */
+    topics: string[];
+    /** data which is supplied by the contract, usually ABI-encoded */
+    data: Uint8Array;
+    /** block_number of the block in which the transaction was included */
+    blockNumber: Long;
+    /** tx_hash is the transaction hash */
+    txHash: string;
+    /** tx_index of the transaction in the block */
+    txIndex: Long;
+    /** block_hash of the block in which the transaction was included */
+    blockHash: string;
+    /** index of the log in the block */
+    index: Long;
+    /**
+     * removed is true if this log was reverted due to a chain
+     * reorganisation. You must pay attention to this field if you receive logs
+     * through a filter query.
+     */
+    removed: boolean;
+}
+/** TxResult stores results of Tx execution. */
+export interface TxResult {
+    /**
+     * contract_address contains the ethereum address of the created contract (if
+     * any). If the state transition is an evm.Call, the contract address will be
+     * empty.
+     */
+    contractAddress: string;
+    /** bloom represents the bloom filter bytes */
+    bloom: Uint8Array;
+    /**
+     * tx_logs contains the transaction hash and the proto-compatible ethereum
+     * logs.
+     */
+    txLogs?: TransactionLogs;
+    /** ret defines the bytes from the execution. */
+    ret: Uint8Array;
+    /** reverted flag is set to true when the call has been reverted */
+    reverted: boolean;
+    /** gas_used notes the amount of gas consumed while execution */
+    gasUsed: Long;
+}
+/** AccessTuple is the element type of an access list. */
+export interface AccessTuple {
+    /** address is a hex formatted ethereum address */
+    address: string;
+    /** storage_keys are hex formatted hashes of the storage keys */
+    storageKeys: string[];
+}
+/** TraceConfig holds extra parameters to trace functions. */
+export interface TraceConfig {
+    /** tracer is a custom javascript tracer */
+    tracer: string;
+    /**
+     * timeout overrides the default timeout of 5 seconds for JavaScript-based tracing
+     * calls
+     */
+    timeout: string;
+    /** reexec defines the number of blocks the tracer is willing to go back */
+    reexec: Long;
+    /** disable_stack switches stack capture */
+    disableStack: boolean;
+    /** disable_storage switches storage capture */
+    disableStorage: boolean;
+    /** debug can be used to print output during capture end */
+    debug: boolean;
+    /** limit defines the maximum length of output, but zero means unlimited */
+    limit: number;
+    /** overrides can be used to execute a trace using future fork rules */
+    overrides?: ChainConfig;
+    /** enable_memory switches memory capture */
+    enableMemory: boolean;
+    /** enable_return_data switches the capture of return data */
+    enableReturnData: boolean;
+    /** tracer_json_config configures the tracer using a JSON string */
+    tracerJsonConfig: string;
+}
+export declare const Params: {
+    encode(message: Params, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): Params;
+    fromJSON(object: any): Params;
+    toJSON(message: Params): unknown;
+    fromPartial(object: DeepPartial<Params>): Params;
+};
+export declare const ChainConfig: {
+    encode(message: ChainConfig, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ChainConfig;
+    fromJSON(object: any): ChainConfig;
+    toJSON(message: ChainConfig): unknown;
+    fromPartial(object: DeepPartial<ChainConfig>): ChainConfig;
+};
+export declare const State: {
+    encode(message: State, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): State;
+    fromJSON(object: any): State;
+    toJSON(message: State): unknown;
+    fromPartial(object: DeepPartial<State>): State;
+};
+export declare const TransactionLogs: {
+    encode(message: TransactionLogs, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): TransactionLogs;
+    fromJSON(object: any): TransactionLogs;
+    toJSON(message: TransactionLogs): unknown;
+    fromPartial(object: DeepPartial<TransactionLogs>): TransactionLogs;
+};
+export declare const Log: {
+    encode(message: Log, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): Log;
+    fromJSON(object: any): Log;
+    toJSON(message: Log): unknown;
+    fromPartial(object: DeepPartial<Log>): Log;
+};
+export declare const TxResult: {
+    encode(message: TxResult, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): TxResult;
+    fromJSON(object: any): TxResult;
+    toJSON(message: TxResult): unknown;
+    fromPartial(object: DeepPartial<TxResult>): TxResult;
+};
+export declare const AccessTuple: {
+    encode(message: AccessTuple, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): AccessTuple;
+    fromJSON(object: any): AccessTuple;
+    toJSON(message: AccessTuple): unknown;
+    fromPartial(object: DeepPartial<AccessTuple>): AccessTuple;
+};
+export declare const TraceConfig: {
+    encode(message: TraceConfig, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): TraceConfig;
+    fromJSON(object: any): TraceConfig;
+    toJSON(message: TraceConfig): unknown;
+    fromPartial(object: DeepPartial<TraceConfig>): TraceConfig;
+};
+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 {};