@burnt-labs/xion-types 0.0.1-test.1762962136

package/types/abstractaccount/lcd.ts

@@ -0,0 +1,130 @@
+//@ts-nocheck
+import { LCDClient } from "@cosmology/lcd";
+export const createLCDClient = async ({
+  restEndpoint
+}: {
+  restEndpoint: string;
+}) => {
+  const requestClient = new LCDClient({
+    restEndpoint
+  });
+  return {
+    abstractaccount: {
+      v1: new (await import("./v1/query.lcd")).LCDQueryClient({
+        requestClient
+      })
+    },
+    cosmos: {
+      auth: {
+        v1beta1: new (await import("../cosmos/auth/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      authz: {
+        v1beta1: new (await import("../cosmos/authz/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      bank: {
+        v1beta1: new (await import("../cosmos/bank/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      base: {
+        node: {
+          v1beta1: new (await import("../cosmos/base/node/v1beta1/query.lcd")).LCDQueryClient({
+            requestClient
+          })
+        },
+        tendermint: {
+          v1beta1: new (await import("../cosmos/base/tendermint/v1beta1/query.lcd")).LCDQueryClient({
+            requestClient
+          })
+        }
+      },
+      circuit: {
+        v1: new (await import("../cosmos/circuit/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      consensus: {
+        v1: new (await import("../cosmos/consensus/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      distribution: {
+        v1beta1: new (await import("../cosmos/distribution/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      epochs: {
+        v1beta1: new (await import("../cosmos/epochs/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      evidence: {
+        v1beta1: new (await import("../cosmos/evidence/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      feegrant: {
+        v1beta1: new (await import("../cosmos/feegrant/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      gov: {
+        v1: new (await import("../cosmos/gov/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        }),
+        v1beta1: new (await import("../cosmos/gov/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      group: {
+        v1: new (await import("../cosmos/group/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      mint: {
+        v1beta1: new (await import("../cosmos/mint/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      nft: {
+        v1beta1: new (await import("../cosmos/nft/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      params: {
+        v1beta1: new (await import("../cosmos/params/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      protocolpool: {
+        v1: new (await import("../cosmos/protocolpool/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      slashing: {
+        v1beta1: new (await import("../cosmos/slashing/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      staking: {
+        v1beta1: new (await import("../cosmos/staking/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      tx: {
+        v1beta1: new (await import("../cosmos/tx/v1beta1/service.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      upgrade: {
+        v1beta1: new (await import("../cosmos/upgrade/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      }
+    }
+  };
+};

package/types/abstractaccount/rpc.query.ts

@@ -0,0 +1,93 @@
+//@ts-nocheck
+import { Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc";
+import { QueryClient } from "@cosmjs/stargate";
+export const createRPCQueryClient = async ({
+  rpcEndpoint
+}: {
+  rpcEndpoint: string | HttpEndpoint;
+}) => {
+  const tmClient = await Tendermint34Client.connect(rpcEndpoint);
+  const client = new QueryClient(tmClient);
+  return {
+    abstractaccount: {
+      v1: (await import("./v1/query.rpc.Query")).createRpcQueryExtension(client)
+    },
+    cosmos: {
+      app: {
+        v1alpha1: (await import("../cosmos/app/v1alpha1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      auth: {
+        v1beta1: (await import("../cosmos/auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      authz: {
+        v1beta1: (await import("../cosmos/authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      autocli: {
+        v1: (await import("../cosmos/autocli/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      bank: {
+        v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      base: {
+        node: {
+          v1beta1: (await import("../cosmos/base/node/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        },
+        tendermint: {
+          v1beta1: (await import("../cosmos/base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+        }
+      },
+      circuit: {
+        v1: (await import("../cosmos/circuit/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      consensus: {
+        v1: (await import("../cosmos/consensus/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      counter: {
+        v1: (await import("../cosmos/counter/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      distribution: {
+        v1beta1: (await import("../cosmos/distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      epochs: {
+        v1beta1: (await import("../cosmos/epochs/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      evidence: {
+        v1beta1: (await import("../cosmos/evidence/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      feegrant: {
+        v1beta1: (await import("../cosmos/feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      gov: {
+        v1: (await import("../cosmos/gov/v1/query.rpc.Query")).createRpcQueryExtension(client),
+        v1beta1: (await import("../cosmos/gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      group: {
+        v1: (await import("../cosmos/group/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      mint: {
+        v1beta1: (await import("../cosmos/mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      nft: {
+        v1beta1: (await import("../cosmos/nft/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      params: {
+        v1beta1: (await import("../cosmos/params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      protocolpool: {
+        v1: (await import("../cosmos/protocolpool/v1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      slashing: {
+        v1beta1: (await import("../cosmos/slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      staking: {
+        v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      },
+      tx: {
+        v1beta1: (await import("../cosmos/tx/v1beta1/service.rpc.Service")).createRpcQueryExtension(client)
+      },
+      upgrade: {
+        v1beta1: (await import("../cosmos/upgrade/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+      }
+    }
+  };
+};

package/types/abstractaccount/rpc.tx.ts

@@ -0,0 +1,74 @@
+//@ts-nocheck
+import { Rpc } from "../helpers";
+export const createRPCMsgClient = async ({
+  rpc
+}: {
+  rpc: Rpc;
+}) => ({
+  abstractaccount: {
+    v1: new (await import("./v1/tx.rpc.msg")).MsgClientImpl(rpc)
+  },
+  cosmos: {
+    auth: {
+      v1beta1: new (await import("../cosmos/auth/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    authz: {
+      v1beta1: new (await import("../cosmos/authz/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    bank: {
+      v1beta1: new (await import("../cosmos/bank/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    benchmark: {
+      v1: new (await import("../cosmos/benchmark/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    circuit: {
+      v1: new (await import("../cosmos/circuit/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    consensus: {
+      v1: new (await import("../cosmos/consensus/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    counter: {
+      v1: new (await import("../cosmos/counter/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    crisis: {
+      v1beta1: new (await import("../cosmos/crisis/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    distribution: {
+      v1beta1: new (await import("../cosmos/distribution/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    evidence: {
+      v1beta1: new (await import("../cosmos/evidence/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    feegrant: {
+      v1beta1: new (await import("../cosmos/feegrant/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    gov: {
+      v1: new (await import("../cosmos/gov/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+      v1beta1: new (await import("../cosmos/gov/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    group: {
+      v1: new (await import("../cosmos/group/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    mint: {
+      v1beta1: new (await import("../cosmos/mint/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    nft: {
+      v1beta1: new (await import("../cosmos/nft/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    protocolpool: {
+      v1: new (await import("../cosmos/protocolpool/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    slashing: {
+      v1beta1: new (await import("../cosmos/slashing/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    staking: {
+      v1beta1: new (await import("../cosmos/staking/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    upgrade: {
+      v1beta1: new (await import("../cosmos/upgrade/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    vesting: {
+      v1beta1: new (await import("../cosmos/vesting/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    }
+  }
+});

package/types/abstractaccount/v1/account.ts

@@ -0,0 +1,250 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../helpers";
+/**
+ * AbstractAccount is a smart contract that is capable of initiating txs.
+ * 
+ * This account type is similar to BaseAccount except for it doesn't have a
+ * pubkey. If a pubkey is needed, it creates and returns a new NilPubKey.
+ */
+export interface AbstractAccount {
+  $typeUrl?: "/abstractaccount.v1.AbstractAccount";
+  address: string;
+  accountNumber: bigint;
+  sequence: bigint;
+}
+export interface AbstractAccountProtoMsg {
+  typeUrl: "/abstractaccount.v1.AbstractAccount";
+  value: Uint8Array;
+}
+/**
+ * AbstractAccount is a smart contract that is capable of initiating txs.
+ * 
+ * This account type is similar to BaseAccount except for it doesn't have a
+ * pubkey. If a pubkey is needed, it creates and returns a new NilPubKey.
+ * @name AbstractAccountAmino
+ * @package abstractaccount.v1
+ * @see proto type: abstractaccount.v1.AbstractAccount
+ */
+export interface AbstractAccountAmino {
+  address?: string;
+  account_number?: string;
+  sequence?: string;
+}
+export interface AbstractAccountAminoMsg {
+  type: "/abstractaccount.v1.AbstractAccount";
+  value: AbstractAccountAmino;
+}
+/**
+ * AbstractAccount is a smart contract that is capable of initiating txs.
+ * 
+ * This account type is similar to BaseAccount except for it doesn't have a
+ * pubkey. If a pubkey is needed, it creates and returns a new NilPubKey.
+ */
+export interface AbstractAccountSDKType {
+  $typeUrl?: "/abstractaccount.v1.AbstractAccount";
+  address: string;
+  account_number: bigint;
+  sequence: bigint;
+}
+/**
+ * NilPubKey is the pubkey type of the AbstractAccount. Basically, it represents
+ * a pubkey that doesn't exist.
+ * 
+ * The actual pubkey of an AbstractAccount (if it has one) is to be stored
+ * inside the contract, not at the SDK level. Signature verification is also
+ * done inside the contract, typically in the BeforeTx hook.
+ */
+export interface NilPubKey {
+  addressBytes: Uint8Array;
+}
+export interface NilPubKeyProtoMsg {
+  typeUrl: "/abstractaccount.v1.NilPubKey";
+  value: Uint8Array;
+}
+/**
+ * NilPubKey is the pubkey type of the AbstractAccount. Basically, it represents
+ * a pubkey that doesn't exist.
+ * 
+ * The actual pubkey of an AbstractAccount (if it has one) is to be stored
+ * inside the contract, not at the SDK level. Signature verification is also
+ * done inside the contract, typically in the BeforeTx hook.
+ * @name NilPubKeyAmino
+ * @package abstractaccount.v1
+ * @see proto type: abstractaccount.v1.NilPubKey
+ */
+export interface NilPubKeyAmino {
+  address_bytes?: string;
+}
+export interface NilPubKeyAminoMsg {
+  type: "abstract-account/NilPubKey";
+  value: NilPubKeyAmino;
+}
+/**
+ * NilPubKey is the pubkey type of the AbstractAccount. Basically, it represents
+ * a pubkey that doesn't exist.
+ * 
+ * The actual pubkey of an AbstractAccount (if it has one) is to be stored
+ * inside the contract, not at the SDK level. Signature verification is also
+ * done inside the contract, typically in the BeforeTx hook.
+ */
+export interface NilPubKeySDKType {
+  address_bytes: Uint8Array;
+}
+function createBaseAbstractAccount(): AbstractAccount {
+  return {
+    $typeUrl: "/abstractaccount.v1.AbstractAccount",
+    address: "",
+    accountNumber: BigInt(0),
+    sequence: BigInt(0)
+  };
+}
+export const AbstractAccount = {
+  typeUrl: "/abstractaccount.v1.AbstractAccount",
+  encode(message: AbstractAccount, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.accountNumber !== BigInt(0)) {
+      writer.uint32(16).uint64(message.accountNumber);
+    }
+    if (message.sequence !== BigInt(0)) {
+      writer.uint32(24).uint64(message.sequence);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): AbstractAccount {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAbstractAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.accountNumber = reader.uint64();
+          break;
+        case 3:
+          message.sequence = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<AbstractAccount>): AbstractAccount {
+    const message = createBaseAbstractAccount();
+    message.address = object.address ?? "";
+    message.accountNumber = object.accountNumber !== undefined && object.accountNumber !== null ? BigInt(object.accountNumber.toString()) : BigInt(0);
+    message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: AbstractAccountAmino): AbstractAccount {
+    const message = createBaseAbstractAccount();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    if (object.account_number !== undefined && object.account_number !== null) {
+      message.accountNumber = BigInt(object.account_number);
+    }
+    if (object.sequence !== undefined && object.sequence !== null) {
+      message.sequence = BigInt(object.sequence);
+    }
+    return message;
+  },
+  toAmino(message: AbstractAccount): AbstractAccountAmino {
+    const obj: any = {};
+    obj.address = message.address === "" ? undefined : message.address;
+    obj.account_number = message.accountNumber !== BigInt(0) ? message.accountNumber?.toString() : undefined;
+    obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: AbstractAccountAminoMsg): AbstractAccount {
+    return AbstractAccount.fromAmino(object.value);
+  },
+  fromProtoMsg(message: AbstractAccountProtoMsg): AbstractAccount {
+    return AbstractAccount.decode(message.value);
+  },
+  toProto(message: AbstractAccount): Uint8Array {
+    return AbstractAccount.encode(message).finish();
+  },
+  toProtoMsg(message: AbstractAccount): AbstractAccountProtoMsg {
+    return {
+      typeUrl: "/abstractaccount.v1.AbstractAccount",
+      value: AbstractAccount.encode(message).finish()
+    };
+  }
+};
+function createBaseNilPubKey(): NilPubKey {
+  return {
+    addressBytes: new Uint8Array()
+  };
+}
+export const NilPubKey = {
+  typeUrl: "/abstractaccount.v1.NilPubKey",
+  encode(message: NilPubKey, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.addressBytes.length !== 0) {
+      writer.uint32(10).bytes(message.addressBytes);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): NilPubKey {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseNilPubKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.addressBytes = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<NilPubKey>): NilPubKey {
+    const message = createBaseNilPubKey();
+    message.addressBytes = object.addressBytes ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object: NilPubKeyAmino): NilPubKey {
+    const message = createBaseNilPubKey();
+    if (object.address_bytes !== undefined && object.address_bytes !== null) {
+      message.addressBytes = bytesFromBase64(object.address_bytes);
+    }
+    return message;
+  },
+  toAmino(message: NilPubKey): NilPubKeyAmino {
+    const obj: any = {};
+    obj.address_bytes = message.addressBytes ? base64FromBytes(message.addressBytes) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: NilPubKeyAminoMsg): NilPubKey {
+    return NilPubKey.fromAmino(object.value);
+  },
+  toAminoMsg(message: NilPubKey): NilPubKeyAminoMsg {
+    return {
+      type: "abstract-account/NilPubKey",
+      value: NilPubKey.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: NilPubKeyProtoMsg): NilPubKey {
+    return NilPubKey.decode(message.value);
+  },
+  toProto(message: NilPubKey): Uint8Array {
+    return NilPubKey.encode(message).finish();
+  },
+  toProtoMsg(message: NilPubKey): NilPubKeyProtoMsg {
+    return {
+      typeUrl: "/abstractaccount.v1.NilPubKey",
+      value: NilPubKey.encode(message).finish()
+    };
+  }
+};

package/types/abstractaccount/v1/events.ts

@@ -0,0 +1,135 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../binary";
+/** EventAccountRegistered is emitted when an AbstractAccount is registered. */
+export interface EventAccountRegistered {
+  creator: string;
+  codeId: bigint;
+  contractAddr: string;
+  accountNumber: bigint;
+}
+export interface EventAccountRegisteredProtoMsg {
+  typeUrl: "/abstractaccount.v1.EventAccountRegistered";
+  value: Uint8Array;
+}
+/**
+ * EventAccountRegistered is emitted when an AbstractAccount is registered.
+ * @name EventAccountRegisteredAmino
+ * @package abstractaccount.v1
+ * @see proto type: abstractaccount.v1.EventAccountRegistered
+ */
+export interface EventAccountRegisteredAmino {
+  creator?: string;
+  code_id?: string;
+  contract_addr?: string;
+  account_number?: string;
+}
+export interface EventAccountRegisteredAminoMsg {
+  type: "/abstractaccount.v1.EventAccountRegistered";
+  value: EventAccountRegisteredAmino;
+}
+/** EventAccountRegistered is emitted when an AbstractAccount is registered. */
+export interface EventAccountRegisteredSDKType {
+  creator: string;
+  code_id: bigint;
+  contract_addr: string;
+  account_number: bigint;
+}
+function createBaseEventAccountRegistered(): EventAccountRegistered {
+  return {
+    creator: "",
+    codeId: BigInt(0),
+    contractAddr: "",
+    accountNumber: BigInt(0)
+  };
+}
+export const EventAccountRegistered = {
+  typeUrl: "/abstractaccount.v1.EventAccountRegistered",
+  encode(message: EventAccountRegistered, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.codeId !== BigInt(0)) {
+      writer.uint32(16).uint64(message.codeId);
+    }
+    if (message.contractAddr !== "") {
+      writer.uint32(26).string(message.contractAddr);
+    }
+    if (message.accountNumber !== BigInt(0)) {
+      writer.uint32(32).uint64(message.accountNumber);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): EventAccountRegistered {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventAccountRegistered();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        case 2:
+          message.codeId = reader.uint64();
+          break;
+        case 3:
+          message.contractAddr = reader.string();
+          break;
+        case 4:
+          message.accountNumber = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<EventAccountRegistered>): EventAccountRegistered {
+    const message = createBaseEventAccountRegistered();
+    message.creator = object.creator ?? "";
+    message.codeId = object.codeId !== undefined && object.codeId !== null ? BigInt(object.codeId.toString()) : BigInt(0);
+    message.contractAddr = object.contractAddr ?? "";
+    message.accountNumber = object.accountNumber !== undefined && object.accountNumber !== null ? BigInt(object.accountNumber.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: EventAccountRegisteredAmino): EventAccountRegistered {
+    const message = createBaseEventAccountRegistered();
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    }
+    if (object.code_id !== undefined && object.code_id !== null) {
+      message.codeId = BigInt(object.code_id);
+    }
+    if (object.contract_addr !== undefined && object.contract_addr !== null) {
+      message.contractAddr = object.contract_addr;
+    }
+    if (object.account_number !== undefined && object.account_number !== null) {
+      message.accountNumber = BigInt(object.account_number);
+    }
+    return message;
+  },
+  toAmino(message: EventAccountRegistered): EventAccountRegisteredAmino {
+    const obj: any = {};
+    obj.creator = message.creator === "" ? undefined : message.creator;
+    obj.code_id = message.codeId !== BigInt(0) ? message.codeId?.toString() : undefined;
+    obj.contract_addr = message.contractAddr === "" ? undefined : message.contractAddr;
+    obj.account_number = message.accountNumber !== BigInt(0) ? message.accountNumber?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: EventAccountRegisteredAminoMsg): EventAccountRegistered {
+    return EventAccountRegistered.fromAmino(object.value);
+  },
+  fromProtoMsg(message: EventAccountRegisteredProtoMsg): EventAccountRegistered {
+    return EventAccountRegistered.decode(message.value);
+  },
+  toProto(message: EventAccountRegistered): Uint8Array {
+    return EventAccountRegistered.encode(message).finish();
+  },
+  toProtoMsg(message: EventAccountRegistered): EventAccountRegisteredProtoMsg {
+    return {
+      typeUrl: "/abstractaccount.v1.EventAccountRegistered",
+      value: EventAccountRegistered.encode(message).finish()
+    };
+  }
+};