@xpla/xplajs 1.7.0-beta.0

package/src/cosmos/autocli/v1/query.rpc.Query.ts

@@ -0,0 +1,31 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { AppOptionsRequest, AppOptionsResponse } from "./query";
+/** RemoteInfoService provides clients with the information they need
+ to build dynamically CLI clients for remote chains. */
+export interface Query {
+  /** AppOptions returns the autocli options for all of the modules in an app. */
+  appOptions(request?: AppOptionsRequest): Promise<AppOptionsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* AppOptions returns the autocli options for all of the modules in an app. */
+  appOptions = async (request: AppOptionsRequest = {}): Promise<AppOptionsResponse> => {
+    const data = AppOptionsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.autocli.v1.Query", "AppOptions", data);
+    return promise.then(data => AppOptionsResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    appOptions(request?: AppOptionsRequest): Promise<AppOptionsResponse> {
+      return queryService.appOptions(request);
+    }
+  };
+};

package/src/cosmos/autocli/v1/query.rpc.func.ts

@@ -0,0 +1,9 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { AppOptionsRequest, AppOptionsResponse } from "./query";
+export const createGetAppOptions = (clientResolver?: RpcResolver) => buildQuery<AppOptionsRequest, AppOptionsResponse>({
+  encode: AppOptionsRequest.encode,
+  decode: AppOptionsResponse.decode,
+  service: "cosmos.autocli.v1.Query",
+  method: "AppOptions",
+  clientResolver
+});

package/src/cosmos/autocli/v1/query.ts

@@ -0,0 +1,288 @@
+import { ModuleOptions, ModuleOptionsAmino } from "./options";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial, isSet } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** AppOptionsRequest is the RemoteInfoService/AppOptions request type. */
+export interface AppOptionsRequest {}
+export interface AppOptionsRequestProtoMsg {
+  typeUrl: "/cosmos.autocli.v1.AppOptionsRequest";
+  value: Uint8Array;
+}
+/** AppOptionsRequest is the RemoteInfoService/AppOptions request type. */
+export interface AppOptionsRequestAmino {}
+export interface AppOptionsRequestAminoMsg {
+  type: "cosmos-sdk/AppOptionsRequest";
+  value: AppOptionsRequestAmino;
+}
+export interface AppOptionsResponse_ModuleOptionsEntry {
+  key: string;
+  value?: ModuleOptions;
+}
+export interface AppOptionsResponse_ModuleOptionsEntryProtoMsg {
+  typeUrl: string;
+  value: Uint8Array;
+}
+export interface AppOptionsResponse_ModuleOptionsEntryAmino {
+  key: string;
+  value?: ModuleOptionsAmino;
+}
+export interface AppOptionsResponse_ModuleOptionsEntryAminoMsg {
+  type: string;
+  value: AppOptionsResponse_ModuleOptionsEntryAmino;
+}
+/** AppOptionsResponse is the RemoteInfoService/AppOptions response type. */
+export interface AppOptionsResponse {
+  /** module_options is a map of module name to autocli module options. */
+  moduleOptions: {
+    [key: string]: ModuleOptions;
+  };
+}
+export interface AppOptionsResponseProtoMsg {
+  typeUrl: "/cosmos.autocli.v1.AppOptionsResponse";
+  value: Uint8Array;
+}
+/** AppOptionsResponse is the RemoteInfoService/AppOptions response type. */
+export interface AppOptionsResponseAmino {
+  /** module_options is a map of module name to autocli module options. */
+  module_options: {
+    [key: string]: ModuleOptionsAmino;
+  };
+}
+export interface AppOptionsResponseAminoMsg {
+  type: "cosmos-sdk/AppOptionsResponse";
+  value: AppOptionsResponseAmino;
+}
+function createBaseAppOptionsRequest(): AppOptionsRequest {
+  return {};
+}
+export const AppOptionsRequest = {
+  typeUrl: "/cosmos.autocli.v1.AppOptionsRequest",
+  aminoType: "cosmos-sdk/AppOptionsRequest",
+  is(o: any): o is AppOptionsRequest {
+    return o && o.$typeUrl === AppOptionsRequest.typeUrl;
+  },
+  isAmino(o: any): o is AppOptionsRequestAmino {
+    return o && o.$typeUrl === AppOptionsRequest.typeUrl;
+  },
+  encode(_: AppOptionsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): AppOptionsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAppOptionsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<AppOptionsRequest>): AppOptionsRequest {
+    const message = createBaseAppOptionsRequest();
+    return message;
+  },
+  fromAmino(_: AppOptionsRequestAmino): AppOptionsRequest {
+    const message = createBaseAppOptionsRequest();
+    return message;
+  },
+  toAmino(_: AppOptionsRequest): AppOptionsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: AppOptionsRequestAminoMsg): AppOptionsRequest {
+    return AppOptionsRequest.fromAmino(object.value);
+  },
+  toAminoMsg(message: AppOptionsRequest): AppOptionsRequestAminoMsg {
+    return {
+      type: "cosmos-sdk/AppOptionsRequest",
+      value: AppOptionsRequest.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: AppOptionsRequestProtoMsg): AppOptionsRequest {
+    return AppOptionsRequest.decode(message.value);
+  },
+  toProto(message: AppOptionsRequest): Uint8Array {
+    return AppOptionsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: AppOptionsRequest): AppOptionsRequestProtoMsg {
+    return {
+      typeUrl: "/cosmos.autocli.v1.AppOptionsRequest",
+      value: AppOptionsRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(AppOptionsRequest.typeUrl, AppOptionsRequest);
+GlobalDecoderRegistry.registerAminoProtoMapping(AppOptionsRequest.aminoType, AppOptionsRequest.typeUrl);
+function createBaseAppOptionsResponse_ModuleOptionsEntry(): AppOptionsResponse_ModuleOptionsEntry {
+  return {
+    key: "",
+    value: undefined
+  };
+}
+export const AppOptionsResponse_ModuleOptionsEntry = {
+  encode(message: AppOptionsResponse_ModuleOptionsEntry, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== undefined) {
+      ModuleOptions.encode(message.value, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): AppOptionsResponse_ModuleOptionsEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAppOptionsResponse_ModuleOptionsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.string();
+          break;
+        case 2:
+          message.value = ModuleOptions.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<AppOptionsResponse_ModuleOptionsEntry>): AppOptionsResponse_ModuleOptionsEntry {
+    const message = createBaseAppOptionsResponse_ModuleOptionsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value !== undefined && object.value !== null ? ModuleOptions.fromPartial(object.value) : undefined;
+    return message;
+  },
+  fromAmino(object: AppOptionsResponse_ModuleOptionsEntryAmino): AppOptionsResponse_ModuleOptionsEntry {
+    const message = createBaseAppOptionsResponse_ModuleOptionsEntry();
+    if (object.key !== undefined && object.key !== null) {
+      message.key = object.key;
+    }
+    if (object.value !== undefined && object.value !== null) {
+      message.value = ModuleOptions.fromAmino(object.value);
+    }
+    return message;
+  },
+  toAmino(message: AppOptionsResponse_ModuleOptionsEntry): AppOptionsResponse_ModuleOptionsEntryAmino {
+    const obj: any = {};
+    obj.key = message.key === "" ? undefined : message.key;
+    obj.value = message.value ? ModuleOptions.toAmino(message.value) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: AppOptionsResponse_ModuleOptionsEntryAminoMsg): AppOptionsResponse_ModuleOptionsEntry {
+    return AppOptionsResponse_ModuleOptionsEntry.fromAmino(object.value);
+  },
+  fromProtoMsg(message: AppOptionsResponse_ModuleOptionsEntryProtoMsg): AppOptionsResponse_ModuleOptionsEntry {
+    return AppOptionsResponse_ModuleOptionsEntry.decode(message.value);
+  },
+  toProto(message: AppOptionsResponse_ModuleOptionsEntry): Uint8Array {
+    return AppOptionsResponse_ModuleOptionsEntry.encode(message).finish();
+  }
+};
+function createBaseAppOptionsResponse(): AppOptionsResponse {
+  return {
+    moduleOptions: {}
+  };
+}
+export const AppOptionsResponse = {
+  typeUrl: "/cosmos.autocli.v1.AppOptionsResponse",
+  aminoType: "cosmos-sdk/AppOptionsResponse",
+  is(o: any): o is AppOptionsResponse {
+    return o && (o.$typeUrl === AppOptionsResponse.typeUrl || isSet(o.moduleOptions));
+  },
+  isAmino(o: any): o is AppOptionsResponseAmino {
+    return o && (o.$typeUrl === AppOptionsResponse.typeUrl || isSet(o.module_options));
+  },
+  encode(message: AppOptionsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    Object.entries(message.moduleOptions).forEach(([key, value]) => {
+      AppOptionsResponse_ModuleOptionsEntry.encode({
+        key: key as any,
+        value
+      }, writer.uint32(10).fork()).ldelim();
+    });
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): AppOptionsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAppOptionsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          const entry1 = AppOptionsResponse_ModuleOptionsEntry.decode(reader, reader.uint32());
+          if (entry1.value !== undefined) {
+            message.moduleOptions[entry1.key] = entry1.value;
+          }
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<AppOptionsResponse>): AppOptionsResponse {
+    const message = createBaseAppOptionsResponse();
+    message.moduleOptions = Object.entries(object.moduleOptions ?? {}).reduce<{
+      [key: string]: ModuleOptions;
+    }>((acc, [key, value]) => {
+      if (value !== undefined) {
+        acc[key] = ModuleOptions.fromPartial(value);
+      }
+      return acc;
+    }, {});
+    return message;
+  },
+  fromAmino(object: AppOptionsResponseAmino): AppOptionsResponse {
+    const message = createBaseAppOptionsResponse();
+    message.moduleOptions = Object.entries(object.module_options ?? {}).reduce<{
+      [key: string]: ModuleOptions;
+    }>((acc, [key, value]) => {
+      if (value !== undefined) {
+        acc[key] = ModuleOptions.fromAmino(value);
+      }
+      return acc;
+    }, {});
+    return message;
+  },
+  toAmino(message: AppOptionsResponse): AppOptionsResponseAmino {
+    const obj: any = {};
+    obj.module_options = {};
+    if (message.moduleOptions) {
+      Object.entries(message.moduleOptions).forEach(([k, v]) => {
+        obj.module_options[k] = ModuleOptions.toAmino(v);
+      });
+    }
+    return obj;
+  },
+  fromAminoMsg(object: AppOptionsResponseAminoMsg): AppOptionsResponse {
+    return AppOptionsResponse.fromAmino(object.value);
+  },
+  toAminoMsg(message: AppOptionsResponse): AppOptionsResponseAminoMsg {
+    return {
+      type: "cosmos-sdk/AppOptionsResponse",
+      value: AppOptionsResponse.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: AppOptionsResponseProtoMsg): AppOptionsResponse {
+    return AppOptionsResponse.decode(message.value);
+  },
+  toProto(message: AppOptionsResponse): Uint8Array {
+    return AppOptionsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: AppOptionsResponse): AppOptionsResponseProtoMsg {
+    return {
+      typeUrl: "/cosmos.autocli.v1.AppOptionsResponse",
+      value: AppOptionsResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(AppOptionsResponse.typeUrl, AppOptionsResponse);
+GlobalDecoderRegistry.registerAminoProtoMapping(AppOptionsResponse.aminoType, AppOptionsResponse.typeUrl);

package/src/cosmos/bank/module/v1/module.ts

@@ -0,0 +1,153 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/** Module is the config object of the bank module. */
+export interface Module {
+  /**
+   * blocked_module_accounts_override configures exceptional module accounts which should be blocked from receiving
+   * funds. If left empty it defaults to the list of account names supplied in the auth module configuration as
+   * module_account_permissions
+   */
+  blockedModuleAccountsOverride: string[];
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+  /**
+   * restrictions_order specifies the order of send restrictions and should be
+   * a list of module names which provide a send restriction instance. If no
+   * order is provided, then restrictions will be applied in alphabetical order
+   * of module names.
+   */
+  restrictionsOrder: string[];
+}
+export interface ModuleProtoMsg {
+  typeUrl: "/cosmos.bank.module.v1.Module";
+  value: Uint8Array;
+}
+/** Module is the config object of the bank module. */
+export interface ModuleAmino {
+  /**
+   * blocked_module_accounts_override configures exceptional module accounts which should be blocked from receiving
+   * funds. If left empty it defaults to the list of account names supplied in the auth module configuration as
+   * module_account_permissions
+   */
+  blocked_module_accounts_override: string[];
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+  /**
+   * restrictions_order specifies the order of send restrictions and should be
+   * a list of module names which provide a send restriction instance. If no
+   * order is provided, then restrictions will be applied in alphabetical order
+   * of module names.
+   */
+  restrictions_order: string[];
+}
+export interface ModuleAminoMsg {
+  type: "cosmos-sdk/Module";
+  value: ModuleAmino;
+}
+function createBaseModule(): Module {
+  return {
+    blockedModuleAccountsOverride: [],
+    authority: "",
+    restrictionsOrder: []
+  };
+}
+export const Module = {
+  typeUrl: "/cosmos.bank.module.v1.Module",
+  aminoType: "cosmos-sdk/Module",
+  is(o: any): o is Module {
+    return o && (o.$typeUrl === Module.typeUrl || Array.isArray(o.blockedModuleAccountsOverride) && (!o.blockedModuleAccountsOverride.length || typeof o.blockedModuleAccountsOverride[0] === "string") && typeof o.authority === "string" && Array.isArray(o.restrictionsOrder) && (!o.restrictionsOrder.length || typeof o.restrictionsOrder[0] === "string"));
+  },
+  isAmino(o: any): o is ModuleAmino {
+    return o && (o.$typeUrl === Module.typeUrl || Array.isArray(o.blocked_module_accounts_override) && (!o.blocked_module_accounts_override.length || typeof o.blocked_module_accounts_override[0] === "string") && typeof o.authority === "string" && Array.isArray(o.restrictions_order) && (!o.restrictions_order.length || typeof o.restrictions_order[0] === "string"));
+  },
+  encode(message: Module, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.blockedModuleAccountsOverride) {
+      writer.uint32(10).string(v!);
+    }
+    if (message.authority !== "") {
+      writer.uint32(18).string(message.authority);
+    }
+    for (const v of message.restrictionsOrder) {
+      writer.uint32(26).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Module {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.blockedModuleAccountsOverride.push(reader.string());
+          break;
+        case 2:
+          message.authority = reader.string();
+          break;
+        case 3:
+          message.restrictionsOrder.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.blockedModuleAccountsOverride = object.blockedModuleAccountsOverride?.map(e => e) || [];
+    message.authority = object.authority ?? "";
+    message.restrictionsOrder = object.restrictionsOrder?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: ModuleAmino): Module {
+    const message = createBaseModule();
+    message.blockedModuleAccountsOverride = object.blocked_module_accounts_override?.map(e => e) || [];
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    message.restrictionsOrder = object.restrictions_order?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: Module): ModuleAmino {
+    const obj: any = {};
+    if (message.blockedModuleAccountsOverride) {
+      obj.blocked_module_accounts_override = message.blockedModuleAccountsOverride.map(e => e);
+    } else {
+      obj.blocked_module_accounts_override = message.blockedModuleAccountsOverride;
+    }
+    obj.authority = message.authority === "" ? undefined : message.authority;
+    if (message.restrictionsOrder) {
+      obj.restrictions_order = message.restrictionsOrder.map(e => e);
+    } else {
+      obj.restrictions_order = message.restrictionsOrder;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ModuleAminoMsg): Module {
+    return Module.fromAmino(object.value);
+  },
+  toAminoMsg(message: Module): ModuleAminoMsg {
+    return {
+      type: "cosmos-sdk/Module",
+      value: Module.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleProtoMsg): Module {
+    return Module.decode(message.value);
+  },
+  toProto(message: Module): Uint8Array {
+    return Module.encode(message).finish();
+  },
+  toProtoMsg(message: Module): ModuleProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.module.v1.Module",
+      value: Module.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Module.typeUrl, Module);
+GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);

package/src/cosmos/bank/v1beta1/authz.ts

@@ -0,0 +1,138 @@
+import { Coin, CoinAmino } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface SendAuthorization {
+  spendLimit: Coin[];
+  /**
+   * allow_list specifies an optional list of addresses to whom the grantee can send tokens on behalf of the
+   * granter. If omitted, any recipient is allowed.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  allowList: string[];
+}
+export interface SendAuthorizationProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.SendAuthorization";
+  value: Uint8Array;
+}
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+export interface SendAuthorizationAmino {
+  spend_limit: CoinAmino[];
+  /**
+   * allow_list specifies an optional list of addresses to whom the grantee can send tokens on behalf of the
+   * granter. If omitted, any recipient is allowed.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  allow_list: string[];
+}
+export interface SendAuthorizationAminoMsg {
+  type: "cosmos-sdk/SendAuthorization";
+  value: SendAuthorizationAmino;
+}
+function createBaseSendAuthorization(): SendAuthorization {
+  return {
+    spendLimit: [],
+    allowList: []
+  };
+}
+export const SendAuthorization = {
+  typeUrl: "/cosmos.bank.v1beta1.SendAuthorization",
+  aminoType: "cosmos-sdk/SendAuthorization",
+  is(o: any): o is SendAuthorization {
+    return o && (o.$typeUrl === SendAuthorization.typeUrl || Array.isArray(o.spendLimit) && (!o.spendLimit.length || Coin.is(o.spendLimit[0])) && Array.isArray(o.allowList) && (!o.allowList.length || typeof o.allowList[0] === "string"));
+  },
+  isAmino(o: any): o is SendAuthorizationAmino {
+    return o && (o.$typeUrl === SendAuthorization.typeUrl || Array.isArray(o.spend_limit) && (!o.spend_limit.length || Coin.isAmino(o.spend_limit[0])) && Array.isArray(o.allow_list) && (!o.allow_list.length || typeof o.allow_list[0] === "string"));
+  },
+  encode(message: SendAuthorization, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.spendLimit) {
+      Coin.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.allowList) {
+      writer.uint32(18).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): SendAuthorization {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendAuthorization();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.spendLimit.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.allowList.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<SendAuthorization>): SendAuthorization {
+    const message = createBaseSendAuthorization();
+    message.spendLimit = object.spendLimit?.map(e => Coin.fromPartial(e)) || [];
+    message.allowList = object.allowList?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: SendAuthorizationAmino): SendAuthorization {
+    const message = createBaseSendAuthorization();
+    message.spendLimit = object.spend_limit?.map(e => Coin.fromAmino(e)) || [];
+    message.allowList = object.allow_list?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: SendAuthorization): SendAuthorizationAmino {
+    const obj: any = {};
+    if (message.spendLimit) {
+      obj.spend_limit = message.spendLimit.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.spend_limit = message.spendLimit;
+    }
+    if (message.allowList) {
+      obj.allow_list = message.allowList.map(e => e);
+    } else {
+      obj.allow_list = message.allowList;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: SendAuthorizationAminoMsg): SendAuthorization {
+    return SendAuthorization.fromAmino(object.value);
+  },
+  toAminoMsg(message: SendAuthorization): SendAuthorizationAminoMsg {
+    return {
+      type: "cosmos-sdk/SendAuthorization",
+      value: SendAuthorization.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: SendAuthorizationProtoMsg): SendAuthorization {
+    return SendAuthorization.decode(message.value);
+  },
+  toProto(message: SendAuthorization): Uint8Array {
+    return SendAuthorization.encode(message).finish();
+  },
+  toProtoMsg(message: SendAuthorization): SendAuthorizationProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.SendAuthorization",
+      value: SendAuthorization.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(SendAuthorization.typeUrl, SendAuthorization);
+GlobalDecoderRegistry.registerAminoProtoMapping(SendAuthorization.aminoType, SendAuthorization.typeUrl);