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

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

@@ -0,0 +1,32 @@
+//@ts-nocheck
+import { Rpc } from "../../../helpers";
+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: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.appOptions = this.appOptions.bind(this);
+  }
+  appOptions(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/types/cosmos/autocli/v1/query.ts

@@ -0,0 +1,298 @@
+//@ts-nocheck
+import { ModuleOptions, ModuleOptionsAmino, ModuleOptionsSDKType } from "./options";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** 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.
+ * @name AppOptionsRequestAmino
+ * @package cosmos.autocli.v1
+ * @see proto type: cosmos.autocli.v1.AppOptionsRequest
+ */
+export interface AppOptionsRequestAmino {}
+export interface AppOptionsRequestAminoMsg {
+  type: "cosmos-sdk/AppOptionsRequest";
+  value: AppOptionsRequestAmino;
+}
+/** AppOptionsRequest is the RemoteInfoService/AppOptions request type. */
+export interface AppOptionsRequestSDKType {}
+export interface AppOptionsResponse_ModuleOptionsEntry {
+  key: string;
+  value?: ModuleOptions;
+}
+export interface AppOptionsResponse_ModuleOptionsEntryProtoMsg {
+  typeUrl: string;
+  value: Uint8Array;
+}
+/**
+ * @name AppOptionsResponse_ModuleOptionsEntryAmino
+ * @package cosmos.autocli.v1
+ * @see proto type: cosmos.autocli.v1.AppOptionsResponse_ModuleOptionsEntry
+ */
+export interface AppOptionsResponse_ModuleOptionsEntryAmino {
+  key?: string;
+  value?: ModuleOptionsAmino;
+}
+export interface AppOptionsResponse_ModuleOptionsEntryAminoMsg {
+  type: string;
+  value: AppOptionsResponse_ModuleOptionsEntryAmino;
+}
+export interface AppOptionsResponse_ModuleOptionsEntrySDKType {
+  key: string;
+  value?: ModuleOptionsSDKType;
+}
+/** 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.
+ * @name AppOptionsResponseAmino
+ * @package cosmos.autocli.v1
+ * @see proto type: cosmos.autocli.v1.AppOptionsResponse
+ */
+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;
+}
+/** AppOptionsResponse is the RemoteInfoService/AppOptions response type. */
+export interface AppOptionsResponseSDKType {
+  module_options: {
+    [key: string]: ModuleOptionsSDKType;
+  };
+}
+function createBaseAppOptionsRequest(): AppOptionsRequest {
+  return {};
+}
+export const AppOptionsRequest = {
+  typeUrl: "/cosmos.autocli.v1.AppOptionsRequest",
+  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(_: Partial<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()
+    };
+  }
+};
+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: Partial<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",
+  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: Partial<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()
+    };
+  }
+};

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

@@ -0,0 +1,156 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** 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.
+ * @name ModuleAmino
+ * @package cosmos.bank.module.v1
+ * @see proto type: cosmos.bank.module.v1.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;
+}
+/** Module is the config object of the bank module. */
+export interface ModuleSDKType {
+  blocked_module_accounts_override: string[];
+  authority: string;
+  restrictions_order: string[];
+}
+function createBaseModule(): Module {
+  return {
+    blockedModuleAccountsOverride: [],
+    authority: "",
+    restrictionsOrder: []
+  };
+}
+export const Module = {
+  typeUrl: "/cosmos.bank.module.v1.Module",
+  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: Partial<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()
+    };
+  }
+};

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

@@ -0,0 +1,134 @@
+//@ts-nocheck
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ */
+export interface SendAuthorization {
+  $typeUrl?: "/cosmos.bank.v1beta1.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.
+   */
+  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.
+ * @name SendAuthorizationAmino
+ * @package cosmos.bank.v1beta1
+ * @see proto type: cosmos.bank.v1beta1.SendAuthorization
+ */
+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.
+   */
+  allow_list?: string[];
+}
+export interface SendAuthorizationAminoMsg {
+  type: "cosmos-sdk/SendAuthorization";
+  value: SendAuthorizationAmino;
+}
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ */
+export interface SendAuthorizationSDKType {
+  $typeUrl?: "/cosmos.bank.v1beta1.SendAuthorization";
+  spend_limit: CoinSDKType[];
+  allow_list: string[];
+}
+function createBaseSendAuthorization(): SendAuthorization {
+  return {
+    $typeUrl: "/cosmos.bank.v1beta1.SendAuthorization",
+    spendLimit: [],
+    allowList: []
+  };
+}
+export const SendAuthorization = {
+  typeUrl: "/cosmos.bank.v1beta1.SendAuthorization",
+  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: Partial<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()
+    };
+  }
+};