injectivejs 1.4.0 → 1.6.0

package/injective/oracle/v1beta1/tx.rpc.func.d.ts

@@ -0,0 +1,10 @@
+import { SigningClientResolver } from "../../../helper-func-types";
+import { MsgRelayProviderPrices, MsgRelayPriceFeedPrice, MsgRelayBandRates, MsgRequestBandIBCRates, MsgRelayCoinbaseMessages, MsgRelayStorkPrices, MsgRelayPythPrices, MsgUpdateParams } from "./tx";
+export declare const createRelayProviderPrices: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRelayProviderPrices, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createRelayPriceFeedPrice: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRelayPriceFeedPrice, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createRelayBandRates: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRelayBandRates, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createRequestBandIBCRates: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRequestBandIBCRates, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createRelayCoinbaseMessages: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRelayCoinbaseMessages, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createRelayStorkMessage: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRelayStorkPrices, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createRelayPythPrices: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgRelayPythPrices, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;
+export declare const createUpdateParams: (clientResolver?: SigningClientResolver) => (signerAddress: string, message: MsgUpdateParams, fee: import("../../../helper-func-types").StdFee | "auto", memo: string) => Promise<import("../../../helper-func-types").DeliverTxResponse>;

package/injective/oracle/v1beta1/tx.rpc.func.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUpdateParams = exports.createRelayPythPrices = exports.createRelayStorkMessage = exports.createRelayCoinbaseMessages = exports.createRequestBandIBCRates = exports.createRelayBandRates = exports.createRelayPriceFeedPrice = exports.createRelayProviderPrices = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const utils_1 = require("@interchainjs/cosmos/utils");
+const tx_1 = require("./tx");
+const createRelayProviderPrices = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRelayProviderPrices.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRelayProviderPrices),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRelayProviderPrices)
+});
+exports.createRelayProviderPrices = createRelayProviderPrices;
+const createRelayPriceFeedPrice = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRelayPriceFeedPrice.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRelayPriceFeedPrice),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRelayPriceFeedPrice)
+});
+exports.createRelayPriceFeedPrice = createRelayPriceFeedPrice;
+const createRelayBandRates = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRelayBandRates.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRelayBandRates),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRelayBandRates)
+});
+exports.createRelayBandRates = createRelayBandRates;
+const createRequestBandIBCRates = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRequestBandIBCRates.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRequestBandIBCRates),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRequestBandIBCRates)
+});
+exports.createRequestBandIBCRates = createRequestBandIBCRates;
+const createRelayCoinbaseMessages = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRelayCoinbaseMessages.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRelayCoinbaseMessages),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRelayCoinbaseMessages)
+});
+exports.createRelayCoinbaseMessages = createRelayCoinbaseMessages;
+const createRelayStorkMessage = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRelayStorkPrices.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRelayStorkPrices),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRelayStorkPrices)
+});
+exports.createRelayStorkMessage = createRelayStorkMessage;
+const createRelayPythPrices = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgRelayPythPrices.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgRelayPythPrices),
+    converters: (0, utils_1.toConverters)(tx_1.MsgRelayPythPrices)
+});
+exports.createRelayPythPrices = createRelayPythPrices;
+const createUpdateParams = (clientResolver) => (0, helper_func_types_1.buildTx)({
+    clientResolver,
+    typeUrl: tx_1.MsgUpdateParams.typeUrl,
+    encoders: (0, utils_1.toEncoders)(tx_1.MsgUpdateParams),
+    converters: (0, utils_1.toConverters)(tx_1.MsgUpdateParams)
+});
+exports.createUpdateParams = createUpdateParams;

package/injective/peggy/v1/attestation.d.ts

@@ -0,0 +1,132 @@
+import { Any, AnyAmino } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * ClaimType is the cosmos type of an event from the counterpart chain that can
+ * be handled
+ */
+export declare enum ClaimType {
+    CLAIM_TYPE_UNKNOWN = 0,
+    CLAIM_TYPE_DEPOSIT = 1,
+    CLAIM_TYPE_WITHDRAW = 2,
+    CLAIM_TYPE_ERC20_DEPLOYED = 3,
+    CLAIM_TYPE_VALSET_UPDATED = 4,
+    UNRECOGNIZED = -1
+}
+export declare const ClaimTypeAmino: typeof ClaimType;
+export declare function claimTypeFromJSON(object: any): ClaimType;
+export declare function claimTypeToJSON(object: ClaimType): string;
+/**
+ * Attestation is an aggregate of `claims` that eventually becomes `observed` by
+ * all orchestrators
+ * EVENT_NONCE:
+ * EventNonce a nonce provided by the peggy contract that is unique per event
+ * fired These event nonces must be relayed in order. This is a correctness
+ * issue, if relaying out of order transaction replay attacks become possible
+ * OBSERVED:
+ * Observed indicates that >67% of validators have attested to the event,
+ * and that the event should be executed by the peggy state machine
+ *
+ * The actual content of the claims is passed in with the transaction making the
+ * claim and then passed through the call stack alongside the attestation while
+ * it is processed the key in which the attestation is stored is keyed on the
+ * exact details of the claim but there is no reason to store those exact
+ * details becuause the next message sender will kindly provide you with them.
+ */
+export interface Attestation {
+    observed: boolean;
+    votes: string[];
+    height: bigint;
+    claim?: Any;
+}
+export interface AttestationProtoMsg {
+    typeUrl: "/injective.peggy.v1.Attestation";
+    value: Uint8Array;
+}
+/**
+ * Attestation is an aggregate of `claims` that eventually becomes `observed` by
+ * all orchestrators
+ * EVENT_NONCE:
+ * EventNonce a nonce provided by the peggy contract that is unique per event
+ * fired These event nonces must be relayed in order. This is a correctness
+ * issue, if relaying out of order transaction replay attacks become possible
+ * OBSERVED:
+ * Observed indicates that >67% of validators have attested to the event,
+ * and that the event should be executed by the peggy state machine
+ *
+ * The actual content of the claims is passed in with the transaction making the
+ * claim and then passed through the call stack alongside the attestation while
+ * it is processed the key in which the attestation is stored is keyed on the
+ * exact details of the claim but there is no reason to store those exact
+ * details becuause the next message sender will kindly provide you with them.
+ */
+export interface AttestationAmino {
+    observed: boolean;
+    votes: string[];
+    height: string;
+    claim?: AnyAmino;
+}
+export interface AttestationAminoMsg {
+    type: "/injective.peggy.v1.Attestation";
+    value: AttestationAmino;
+}
+/**
+ * ERC20Token unique identifier for an Ethereum ERC20 token.
+ * CONTRACT:
+ * The contract address on ETH of the token, this could be a Cosmos
+ * originated token, if so it will be the ERC20 address of the representation
+ * (note: developers should look up the token symbol using the address on ETH to
+ * display for UI)
+ */
+export interface ERC20Token {
+    contract: string;
+    amount: string;
+}
+export interface ERC20TokenProtoMsg {
+    typeUrl: "/injective.peggy.v1.ERC20Token";
+    value: Uint8Array;
+}
+/**
+ * ERC20Token unique identifier for an Ethereum ERC20 token.
+ * CONTRACT:
+ * The contract address on ETH of the token, this could be a Cosmos
+ * originated token, if so it will be the ERC20 address of the representation
+ * (note: developers should look up the token symbol using the address on ETH to
+ * display for UI)
+ */
+export interface ERC20TokenAmino {
+    contract: string;
+    amount: string;
+}
+export interface ERC20TokenAminoMsg {
+    type: "/injective.peggy.v1.ERC20Token";
+    value: ERC20TokenAmino;
+}
+export declare const Attestation: {
+    typeUrl: string;
+    is(o: any): o is Attestation;
+    isAmino(o: any): o is AttestationAmino;
+    encode(message: Attestation, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Attestation;
+    fromPartial(object: DeepPartial<Attestation>): Attestation;
+    fromAmino(object: AttestationAmino): Attestation;
+    toAmino(message: Attestation): AttestationAmino;
+    fromAminoMsg(object: AttestationAminoMsg): Attestation;
+    fromProtoMsg(message: AttestationProtoMsg): Attestation;
+    toProto(message: Attestation): Uint8Array;
+    toProtoMsg(message: Attestation): AttestationProtoMsg;
+};
+export declare const ERC20Token: {
+    typeUrl: string;
+    is(o: any): o is ERC20Token;
+    isAmino(o: any): o is ERC20TokenAmino;
+    encode(message: ERC20Token, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ERC20Token;
+    fromPartial(object: DeepPartial<ERC20Token>): ERC20Token;
+    fromAmino(object: ERC20TokenAmino): ERC20Token;
+    toAmino(message: ERC20Token): ERC20TokenAmino;
+    fromAminoMsg(object: ERC20TokenAminoMsg): ERC20Token;
+    fromProtoMsg(message: ERC20TokenProtoMsg): ERC20Token;
+    toProto(message: ERC20Token): Uint8Array;
+    toProtoMsg(message: ERC20Token): ERC20TokenProtoMsg;
+};

package/injective/peggy/v1/attestation.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20Token = exports.Attestation = exports.claimTypeToJSON = exports.claimTypeFromJSON = exports.ClaimTypeAmino = exports.ClaimType = void 0;
+const any_1 = require("../../../google/protobuf/any");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+/**
+ * ClaimType is the cosmos type of an event from the counterpart chain that can
+ * be handled
+ */
+var ClaimType;
+(function (ClaimType) {
+    ClaimType[ClaimType["CLAIM_TYPE_UNKNOWN"] = 0] = "CLAIM_TYPE_UNKNOWN";
+    ClaimType[ClaimType["CLAIM_TYPE_DEPOSIT"] = 1] = "CLAIM_TYPE_DEPOSIT";
+    ClaimType[ClaimType["CLAIM_TYPE_WITHDRAW"] = 2] = "CLAIM_TYPE_WITHDRAW";
+    ClaimType[ClaimType["CLAIM_TYPE_ERC20_DEPLOYED"] = 3] = "CLAIM_TYPE_ERC20_DEPLOYED";
+    ClaimType[ClaimType["CLAIM_TYPE_VALSET_UPDATED"] = 4] = "CLAIM_TYPE_VALSET_UPDATED";
+    ClaimType[ClaimType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ClaimType || (exports.ClaimType = ClaimType = {}));
+exports.ClaimTypeAmino = ClaimType;
+function claimTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "CLAIM_TYPE_UNKNOWN":
+            return ClaimType.CLAIM_TYPE_UNKNOWN;
+        case 1:
+        case "CLAIM_TYPE_DEPOSIT":
+            return ClaimType.CLAIM_TYPE_DEPOSIT;
+        case 2:
+        case "CLAIM_TYPE_WITHDRAW":
+            return ClaimType.CLAIM_TYPE_WITHDRAW;
+        case 3:
+        case "CLAIM_TYPE_ERC20_DEPLOYED":
+            return ClaimType.CLAIM_TYPE_ERC20_DEPLOYED;
+        case 4:
+        case "CLAIM_TYPE_VALSET_UPDATED":
+            return ClaimType.CLAIM_TYPE_VALSET_UPDATED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ClaimType.UNRECOGNIZED;
+    }
+}
+exports.claimTypeFromJSON = claimTypeFromJSON;
+function claimTypeToJSON(object) {
+    switch (object) {
+        case ClaimType.CLAIM_TYPE_UNKNOWN:
+            return "CLAIM_TYPE_UNKNOWN";
+        case ClaimType.CLAIM_TYPE_DEPOSIT:
+            return "CLAIM_TYPE_DEPOSIT";
+        case ClaimType.CLAIM_TYPE_WITHDRAW:
+            return "CLAIM_TYPE_WITHDRAW";
+        case ClaimType.CLAIM_TYPE_ERC20_DEPLOYED:
+            return "CLAIM_TYPE_ERC20_DEPLOYED";
+        case ClaimType.CLAIM_TYPE_VALSET_UPDATED:
+            return "CLAIM_TYPE_VALSET_UPDATED";
+        case ClaimType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.claimTypeToJSON = claimTypeToJSON;
+function createBaseAttestation() {
+    return {
+        observed: false,
+        votes: [],
+        height: BigInt(0),
+        claim: undefined
+    };
+}
+exports.Attestation = {
+    typeUrl: "/injective.peggy.v1.Attestation",
+    is(o) {
+        return o && (o.$typeUrl === exports.Attestation.typeUrl || typeof o.observed === "boolean" && Array.isArray(o.votes) && (!o.votes.length || typeof o.votes[0] === "string") && typeof o.height === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Attestation.typeUrl || typeof o.observed === "boolean" && Array.isArray(o.votes) && (!o.votes.length || typeof o.votes[0] === "string") && typeof o.height === "bigint");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.observed === true) {
+            writer.uint32(8).bool(message.observed);
+        }
+        for (const v of message.votes) {
+            writer.uint32(18).string(v);
+        }
+        if (message.height !== BigInt(0)) {
+            writer.uint32(24).uint64(message.height);
+        }
+        if (message.claim !== undefined) {
+            any_1.Any.encode(message.claim, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAttestation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.observed = reader.bool();
+                    break;
+                case 2:
+                    message.votes.push(reader.string());
+                    break;
+                case 3:
+                    message.height = reader.uint64();
+                    break;
+                case 4:
+                    message.claim = any_1.Any.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAttestation();
+        message.observed = object.observed ?? false;
+        message.votes = object.votes?.map(e => e) || [];
+        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+        message.claim = object.claim !== undefined && object.claim !== null ? any_1.Any.fromPartial(object.claim) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAttestation();
+        if (object.observed !== undefined && object.observed !== null) {
+            message.observed = object.observed;
+        }
+        message.votes = object.votes?.map(e => e) || [];
+        if (object.height !== undefined && object.height !== null) {
+            message.height = BigInt(object.height);
+        }
+        if (object.claim !== undefined && object.claim !== null) {
+            message.claim = any_1.Any.fromAmino(object.claim);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.observed = message.observed === false ? undefined : message.observed;
+        if (message.votes) {
+            obj.votes = message.votes.map(e => e);
+        }
+        else {
+            obj.votes = message.votes;
+        }
+        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
+        obj.claim = message.claim ? any_1.Any.toAmino(message.claim) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Attestation.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Attestation.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Attestation.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.peggy.v1.Attestation",
+            value: exports.Attestation.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Attestation.typeUrl, exports.Attestation);
+function createBaseERC20Token() {
+    return {
+        contract: "",
+        amount: ""
+    };
+}
+exports.ERC20Token = {
+    typeUrl: "/injective.peggy.v1.ERC20Token",
+    is(o) {
+        return o && (o.$typeUrl === exports.ERC20Token.typeUrl || typeof o.contract === "string" && typeof o.amount === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.ERC20Token.typeUrl || typeof o.contract === "string" && typeof o.amount === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.contract !== "") {
+            writer.uint32(10).string(message.contract);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(message.amount);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseERC20Token();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contract = reader.string();
+                    break;
+                case 2:
+                    message.amount = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseERC20Token();
+        message.contract = object.contract ?? "";
+        message.amount = object.amount ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseERC20Token();
+        if (object.contract !== undefined && object.contract !== null) {
+            message.contract = object.contract;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.contract = message.contract === "" ? undefined : message.contract;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ERC20Token.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ERC20Token.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ERC20Token.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/injective.peggy.v1.ERC20Token",
+            value: exports.ERC20Token.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.ERC20Token.typeUrl, exports.ERC20Token);

package/injective/peggy/v1/batch.d.ts

@@ -0,0 +1,79 @@
+import { ERC20Token, ERC20TokenAmino } from "./attestation";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** OutgoingTxBatch represents a batch of transactions going from Peggy to ETH */
+export interface OutgoingTxBatch {
+    batchNonce: bigint;
+    batchTimeout: bigint;
+    transactions: OutgoingTransferTx[];
+    tokenContract: string;
+    block: bigint;
+}
+export interface OutgoingTxBatchProtoMsg {
+    typeUrl: "/injective.peggy.v1.OutgoingTxBatch";
+    value: Uint8Array;
+}
+/** OutgoingTxBatch represents a batch of transactions going from Peggy to ETH */
+export interface OutgoingTxBatchAmino {
+    batch_nonce: string;
+    batch_timeout: string;
+    transactions: OutgoingTransferTxAmino[];
+    token_contract: string;
+    block: string;
+}
+export interface OutgoingTxBatchAminoMsg {
+    type: "/injective.peggy.v1.OutgoingTxBatch";
+    value: OutgoingTxBatchAmino;
+}
+/** OutgoingTransferTx represents an individual send from Peggy to ETH */
+export interface OutgoingTransferTx {
+    id: bigint;
+    sender: string;
+    destAddress: string;
+    erc20Token?: ERC20Token;
+    erc20Fee?: ERC20Token;
+}
+export interface OutgoingTransferTxProtoMsg {
+    typeUrl: "/injective.peggy.v1.OutgoingTransferTx";
+    value: Uint8Array;
+}
+/** OutgoingTransferTx represents an individual send from Peggy to ETH */
+export interface OutgoingTransferTxAmino {
+    id: string;
+    sender: string;
+    dest_address: string;
+    erc20_token?: ERC20TokenAmino;
+    erc20_fee?: ERC20TokenAmino;
+}
+export interface OutgoingTransferTxAminoMsg {
+    type: "/injective.peggy.v1.OutgoingTransferTx";
+    value: OutgoingTransferTxAmino;
+}
+export declare const OutgoingTxBatch: {
+    typeUrl: string;
+    is(o: any): o is OutgoingTxBatch;
+    isAmino(o: any): o is OutgoingTxBatchAmino;
+    encode(message: OutgoingTxBatch, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): OutgoingTxBatch;
+    fromPartial(object: DeepPartial<OutgoingTxBatch>): OutgoingTxBatch;
+    fromAmino(object: OutgoingTxBatchAmino): OutgoingTxBatch;
+    toAmino(message: OutgoingTxBatch): OutgoingTxBatchAmino;
+    fromAminoMsg(object: OutgoingTxBatchAminoMsg): OutgoingTxBatch;
+    fromProtoMsg(message: OutgoingTxBatchProtoMsg): OutgoingTxBatch;
+    toProto(message: OutgoingTxBatch): Uint8Array;
+    toProtoMsg(message: OutgoingTxBatch): OutgoingTxBatchProtoMsg;
+};
+export declare const OutgoingTransferTx: {
+    typeUrl: string;
+    is(o: any): o is OutgoingTransferTx;
+    isAmino(o: any): o is OutgoingTransferTxAmino;
+    encode(message: OutgoingTransferTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): OutgoingTransferTx;
+    fromPartial(object: DeepPartial<OutgoingTransferTx>): OutgoingTransferTx;
+    fromAmino(object: OutgoingTransferTxAmino): OutgoingTransferTx;
+    toAmino(message: OutgoingTransferTx): OutgoingTransferTxAmino;
+    fromAminoMsg(object: OutgoingTransferTxAminoMsg): OutgoingTransferTx;
+    fromProtoMsg(message: OutgoingTransferTxProtoMsg): OutgoingTransferTx;
+    toProto(message: OutgoingTransferTx): Uint8Array;
+    toProtoMsg(message: OutgoingTransferTx): OutgoingTransferTxProtoMsg;
+};