@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/esm/google/protobuf/descriptor.js

@@ -26,6 +26,9 @@ export var Edition;
      */
     Edition[Edition["EDITION_2023"] = 1000] = "EDITION_2023";
     Edition[Edition["EDITION_2024"] = 1001] = "EDITION_2024";
+    Edition[Edition["EDITION_2026"] = 1002] = "EDITION_2026";
+    /** EDITION_UNSTABLE - A placeholder edition for developing and testing unscheduled features. */
+    Edition[Edition["EDITION_UNSTABLE"] = 9999] = "EDITION_UNSTABLE";
     /**
      * EDITION_1_TEST_ONLY - Placeholder editions for testing feature resolution.  These should not be
      * used or relied on outside of tests.
@@ -64,6 +67,12 @@ export function editionFromJSON(object) {
         case 1001:
         case "EDITION_2024":
             return Edition.EDITION_2024;
+        case 1002:
+        case "EDITION_2026":
+            return Edition.EDITION_2026;
+        case 9999:
+        case "EDITION_UNSTABLE":
+            return Edition.EDITION_UNSTABLE;
         case 1:
         case "EDITION_1_TEST_ONLY":
             return Edition.EDITION_1_TEST_ONLY;
@@ -102,6 +111,10 @@ export function editionToJSON(object) {
             return "EDITION_2023";
         case Edition.EDITION_2024:
             return "EDITION_2024";
+        case Edition.EDITION_2026:
+            return "EDITION_2026";
+        case Edition.EDITION_UNSTABLE:
+            return "EDITION_UNSTABLE";
         case Edition.EDITION_1_TEST_ONLY:
             return "EDITION_1_TEST_ONLY";
         case Edition.EDITION_2_TEST_ONLY:
@@ -886,6 +899,7 @@ export var FeatureSet_EnforceNamingStyle;
     FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["ENFORCE_NAMING_STYLE_UNKNOWN"] = 0] = "ENFORCE_NAMING_STYLE_UNKNOWN";
     FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE2024"] = 1] = "STYLE2024";
     FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE_LEGACY"] = 2] = "STYLE_LEGACY";
+    FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE2026"] = 3] = "STYLE2026";
     FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(FeatureSet_EnforceNamingStyle || (FeatureSet_EnforceNamingStyle = {}));
 export const FeatureSet_EnforceNamingStyleAmino = FeatureSet_EnforceNamingStyle;
@@ -900,6 +914,9 @@ export function featureSet_EnforceNamingStyleFromJSON(object) {
         case 2:
         case "STYLE_LEGACY":
             return FeatureSet_EnforceNamingStyle.STYLE_LEGACY;
+        case 3:
+        case "STYLE2026":
+            return FeatureSet_EnforceNamingStyle.STYLE2026;
         case -1:
         case "UNRECOGNIZED":
         default:
@@ -914,6 +931,8 @@ export function featureSet_EnforceNamingStyleToJSON(object) {
             return "STYLE2024";
         case FeatureSet_EnforceNamingStyle.STYLE_LEGACY:
             return "STYLE_LEGACY";
+        case FeatureSet_EnforceNamingStyle.STYLE2026:
+            return "STYLE2026";
         case FeatureSet_EnforceNamingStyle.UNRECOGNIZED:
         default:
             return "UNRECOGNIZED";
@@ -977,6 +996,54 @@ export function featureSet_VisibilityFeature_DefaultSymbolVisibilityToJSON(objec
             return "UNRECOGNIZED";
     }
 }
+export var FeatureSet_ProtoLimitsFeature_EnforceProtoLimits;
+(function (FeatureSet_ProtoLimitsFeature_EnforceProtoLimits) {
+    FeatureSet_ProtoLimitsFeature_EnforceProtoLimits[FeatureSet_ProtoLimitsFeature_EnforceProtoLimits["PROTO_LIMITS_UNKNOWN"] = 0] = "PROTO_LIMITS_UNKNOWN";
+    /**
+     * LEGACY_NO_EXPLICIT_LIMITS - Default pre-EDITION_2026: there are no limit enforcement at the protoc
+     * level. Practical limits still exist, but they will tend to fail while
+     * compiling protoc-generated code, and these limits tend to be language
+     * or toolchain specific.
+     */
+    FeatureSet_ProtoLimitsFeature_EnforceProtoLimits[FeatureSet_ProtoLimitsFeature_EnforceProtoLimits["LEGACY_NO_EXPLICIT_LIMITS"] = 1] = "LEGACY_NO_EXPLICIT_LIMITS";
+    /**
+     * PROTO_LIMITS2026 - A set of limits enforced by Edition 2026 by default. For a detailed
+     * list of all the limits please consult the Edition 2026 documentation.
+     */
+    FeatureSet_ProtoLimitsFeature_EnforceProtoLimits[FeatureSet_ProtoLimitsFeature_EnforceProtoLimits["PROTO_LIMITS2026"] = 2] = "PROTO_LIMITS2026";
+    FeatureSet_ProtoLimitsFeature_EnforceProtoLimits[FeatureSet_ProtoLimitsFeature_EnforceProtoLimits["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(FeatureSet_ProtoLimitsFeature_EnforceProtoLimits || (FeatureSet_ProtoLimitsFeature_EnforceProtoLimits = {}));
+export const FeatureSet_ProtoLimitsFeature_EnforceProtoLimitsAmino = FeatureSet_ProtoLimitsFeature_EnforceProtoLimits;
+export function featureSet_ProtoLimitsFeature_EnforceProtoLimitsFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "PROTO_LIMITS_UNKNOWN":
+            return FeatureSet_ProtoLimitsFeature_EnforceProtoLimits.PROTO_LIMITS_UNKNOWN;
+        case 1:
+        case "LEGACY_NO_EXPLICIT_LIMITS":
+            return FeatureSet_ProtoLimitsFeature_EnforceProtoLimits.LEGACY_NO_EXPLICIT_LIMITS;
+        case 2:
+        case "PROTO_LIMITS2026":
+            return FeatureSet_ProtoLimitsFeature_EnforceProtoLimits.PROTO_LIMITS2026;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return FeatureSet_ProtoLimitsFeature_EnforceProtoLimits.UNRECOGNIZED;
+    }
+}
+export function featureSet_ProtoLimitsFeature_EnforceProtoLimitsToJSON(object) {
+    switch (object) {
+        case FeatureSet_ProtoLimitsFeature_EnforceProtoLimits.PROTO_LIMITS_UNKNOWN:
+            return "PROTO_LIMITS_UNKNOWN";
+        case FeatureSet_ProtoLimitsFeature_EnforceProtoLimits.LEGACY_NO_EXPLICIT_LIMITS:
+            return "LEGACY_NO_EXPLICIT_LIMITS";
+        case FeatureSet_ProtoLimitsFeature_EnforceProtoLimits.PROTO_LIMITS2026:
+            return "PROTO_LIMITS2026";
+        case FeatureSet_ProtoLimitsFeature_EnforceProtoLimits.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
 /**
  * Represents the identified object's effect on the element in the original
  * .proto file.
@@ -3617,7 +3684,8 @@ function createBaseFieldOptions_FeatureSupport() {
         editionIntroduced: 1,
         editionDeprecated: 1,
         deprecationWarning: "",
-        editionRemoved: 1
+        editionRemoved: 1,
+        removalError: ""
     };
 }
 /**
@@ -3641,6 +3709,9 @@ export const FieldOptions_FeatureSupport = {
         if (message.editionRemoved !== 1) {
             writer.uint32(32).int32(message.editionRemoved);
         }
+        if (message.removalError !== "") {
+            writer.uint32(42).string(message.removalError);
+        }
         return writer;
     },
     decode(input, length) {
@@ -3662,6 +3733,9 @@ export const FieldOptions_FeatureSupport = {
                 case 4:
                     message.editionRemoved = reader.int32();
                     break;
+                case 5:
+                    message.removalError = reader.string();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -3675,6 +3749,7 @@ export const FieldOptions_FeatureSupport = {
         message.editionDeprecated = object.editionDeprecated ?? 1;
         message.deprecationWarning = object.deprecationWarning ?? "";
         message.editionRemoved = object.editionRemoved ?? 1;
+        message.removalError = object.removalError ?? "";
         return message;
     },
     fromAmino(object) {
@@ -3691,6 +3766,9 @@ export const FieldOptions_FeatureSupport = {
         if (object.edition_removed !== undefined && object.edition_removed !== null) {
             message.editionRemoved = object.edition_removed;
         }
+        if (object.removal_error !== undefined && object.removal_error !== null) {
+            message.removalError = object.removal_error;
+        }
         return message;
     },
     toAmino(message) {
@@ -3699,6 +3777,7 @@ export const FieldOptions_FeatureSupport = {
         obj.edition_deprecated = message.editionDeprecated === 1 ? undefined : message.editionDeprecated;
         obj.deprecation_warning = message.deprecationWarning === "" ? undefined : message.deprecationWarning;
         obj.edition_removed = message.editionRemoved === 1 ? undefined : message.editionRemoved;
+        obj.removal_error = message.removalError === "" ? undefined : message.removalError;
         return obj;
     },
     fromAminoMsg(object) {
@@ -4675,6 +4754,61 @@ export const FeatureSet_VisibilityFeature = {
         };
     }
 };
+function createBaseFeatureSet_ProtoLimitsFeature() {
+    return {};
+}
+/**
+ * @name FeatureSet_ProtoLimitsFeature
+ * @package google.protobuf
+ * @see proto type: google.protobuf.ProtoLimitsFeature
+ */
+export const FeatureSet_ProtoLimitsFeature = {
+    typeUrl: "/google.protobuf.ProtoLimitsFeature",
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFeatureSet_ProtoLimitsFeature();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseFeatureSet_ProtoLimitsFeature();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseFeatureSet_ProtoLimitsFeature();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return FeatureSet_ProtoLimitsFeature.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return FeatureSet_ProtoLimitsFeature.decode(message.value);
+    },
+    toProto(message) {
+        return FeatureSet_ProtoLimitsFeature.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.protobuf.ProtoLimitsFeature",
+            value: FeatureSet_ProtoLimitsFeature.encode(message).finish()
+        };
+    }
+};
 function createBaseFeatureSetDefaults() {
     return {
         defaults: [],

package/esm/google/protobuf/timestamp.js

@@ -80,8 +80,8 @@ function createBaseTimestamp() {
  * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
  * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
  * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
- * is required. A proto3 JSON serializer should always use UTC (as indicated by
- * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * is required. A ProtoJSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a ProtoJSON parser should be
  * able to accept both UTC and other timezones (as indicated by an offset).
  *
  * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past

package/esm/ibc/applications/gmp/v1/account.js

@@ -0,0 +1,271 @@
+//@ts-nocheck
+import { Any } from "../../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+function createBaseAccountIdentifier() {
+    return {
+        clientId: "",
+        sender: "",
+        salt: new Uint8Array()
+    };
+}
+/**
+ * AccountIdentifier is used to identify a ICS27 account.
+ * @name AccountIdentifier
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.AccountIdentifier
+ */
+export const AccountIdentifier = {
+    typeUrl: "/ibc.applications.gmp.v1.AccountIdentifier",
+    aminoType: "cosmos-sdk/AccountIdentifier",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.clientId !== "") {
+            writer.uint32(10).string(message.clientId);
+        }
+        if (message.sender !== "") {
+            writer.uint32(18).string(message.sender);
+        }
+        if (message.salt.length !== 0) {
+            writer.uint32(26).bytes(message.salt);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAccountIdentifier();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.clientId = reader.string();
+                    break;
+                case 2:
+                    message.sender = reader.string();
+                    break;
+                case 3:
+                    message.salt = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAccountIdentifier();
+        message.clientId = object.clientId ?? "";
+        message.sender = object.sender ?? "";
+        message.salt = object.salt ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAccountIdentifier();
+        if (object.client_id !== undefined && object.client_id !== null) {
+            message.clientId = object.client_id;
+        }
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.salt !== undefined && object.salt !== null) {
+            message.salt = bytesFromBase64(object.salt);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.client_id = message.clientId === "" ? undefined : message.clientId;
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.salt = message.salt ? base64FromBytes(message.salt) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return AccountIdentifier.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/AccountIdentifier",
+            value: AccountIdentifier.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return AccountIdentifier.decode(message.value);
+    },
+    toProto(message) {
+        return AccountIdentifier.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.AccountIdentifier",
+            value: AccountIdentifier.encode(message).finish()
+        };
+    }
+};
+function createBaseICS27Account() {
+    return {
+        address: "",
+        accountId: undefined
+    };
+}
+/**
+ * An ICS27Account is defined as a BaseAccount & the account identifier
+ * @name ICS27Account
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.ICS27Account
+ */
+export const ICS27Account = {
+    typeUrl: "/ibc.applications.gmp.v1.ICS27Account",
+    aminoType: "cosmos-sdk/ICS27Account",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.accountId !== undefined) {
+            AccountIdentifier.encode(message.accountId, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseICS27Account();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.accountId = AccountIdentifier.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseICS27Account();
+        message.address = object.address ?? "";
+        message.accountId = object.accountId !== undefined && object.accountId !== null ? AccountIdentifier.fromPartial(object.accountId) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseICS27Account();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.account_id !== undefined && object.account_id !== null) {
+            message.accountId = AccountIdentifier.fromAmino(object.account_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.account_id = message.accountId ? AccountIdentifier.toAmino(message.accountId) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ICS27Account.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/ICS27Account",
+            value: ICS27Account.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return ICS27Account.decode(message.value);
+    },
+    toProto(message) {
+        return ICS27Account.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.ICS27Account",
+            value: ICS27Account.encode(message).finish()
+        };
+    }
+};
+function createBaseCosmosTx() {
+    return {
+        messages: []
+    };
+}
+/**
+ * CosmosTx contains a list of sdk.Msg's. It should be used when sending transactions to an SDK host chain.
+ * @name CosmosTx
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.CosmosTx
+ */
+export const CosmosTx = {
+    typeUrl: "/ibc.applications.gmp.v1.CosmosTx",
+    aminoType: "cosmos-sdk/CosmosTx",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.messages) {
+            Any.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCosmosTx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.messages.push(Any.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCosmosTx();
+        message.messages = object.messages?.map(e => Any.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCosmosTx();
+        message.messages = object.messages?.map(e => Any.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.messages) {
+            obj.messages = message.messages.map(e => e ? Any.toAmino(e) : undefined);
+        }
+        else {
+            obj.messages = message.messages;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return CosmosTx.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/CosmosTx",
+            value: CosmosTx.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return CosmosTx.decode(message.value);
+    },
+    toProto(message) {
+        return CosmosTx.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.CosmosTx",
+            value: CosmosTx.encode(message).finish()
+        };
+    }
+};

package/esm/ibc/applications/gmp/v1/genesis.js

@@ -0,0 +1,170 @@
+//@ts-nocheck
+import { AccountIdentifier } from "./account";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseGenesisState() {
+    return {
+        ics27Accounts: []
+    };
+}
+/**
+ * GenesisState defines the 27-gmp genesis state
+ * @name GenesisState
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/ibc.applications.gmp.v1.GenesisState",
+    aminoType: "cosmos-sdk/GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.ics27Accounts) {
+            RegisteredICS27Account.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    message.ics27Accounts.push(RegisteredICS27Account.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.ics27Accounts = object.ics27Accounts?.map(e => RegisteredICS27Account.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.ics27Accounts = object.ics27_accounts?.map(e => RegisteredICS27Account.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.ics27Accounts) {
+            obj.ics27_accounts = message.ics27Accounts.map(e => e ? RegisteredICS27Account.toAmino(e) : undefined);
+        }
+        else {
+            obj.ics27_accounts = message.ics27Accounts;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/GenesisState",
+            value: GenesisState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};
+function createBaseRegisteredICS27Account() {
+    return {
+        accountAddress: "",
+        accountId: AccountIdentifier.fromPartial({})
+    };
+}
+/**
+ * RegisteredICS27Account contains an account identifier and associated interchain account address
+ * @name RegisteredICS27Account
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.RegisteredICS27Account
+ */
+export const RegisteredICS27Account = {
+    typeUrl: "/ibc.applications.gmp.v1.RegisteredICS27Account",
+    aminoType: "cosmos-sdk/RegisteredICS27Account",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.accountAddress !== "") {
+            writer.uint32(10).string(message.accountAddress);
+        }
+        if (message.accountId !== undefined) {
+            AccountIdentifier.encode(message.accountId, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRegisteredICS27Account();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.accountAddress = reader.string();
+                    break;
+                case 2:
+                    message.accountId = AccountIdentifier.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRegisteredICS27Account();
+        message.accountAddress = object.accountAddress ?? "";
+        message.accountId = object.accountId !== undefined && object.accountId !== null ? AccountIdentifier.fromPartial(object.accountId) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRegisteredICS27Account();
+        if (object.account_address !== undefined && object.account_address !== null) {
+            message.accountAddress = object.account_address;
+        }
+        if (object.account_id !== undefined && object.account_id !== null) {
+            message.accountId = AccountIdentifier.fromAmino(object.account_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.account_address = message.accountAddress === "" ? undefined : message.accountAddress;
+        obj.account_id = message.accountId ? AccountIdentifier.toAmino(message.accountId) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RegisteredICS27Account.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/RegisteredICS27Account",
+            value: RegisteredICS27Account.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return RegisteredICS27Account.decode(message.value);
+    },
+    toProto(message) {
+        return RegisteredICS27Account.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.RegisteredICS27Account",
+            value: RegisteredICS27Account.encode(message).finish()
+        };
+    }
+};