decentralcardgame-cardchain-client-ts 0.0.1 → 0.0.3

package/ibc.applications.interchain_accounts.controller.v1/types/ibc/applications/interchain_accounts/controller/v1/tx.ts

@@ -0,0 +1,361 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { InterchainAccountPacketData } from "../../v1/packet";
+
+export const protobufPackage = "ibc.applications.interchain_accounts.controller.v1";
+
+/** MsgRegisterInterchainAccount defines the payload for Msg/MsgRegisterInterchainAccount */
+export interface MsgRegisterInterchainAccount {
+  owner: string;
+  connectionId: string;
+  version: string;
+}
+
+/** MsgRegisterInterchainAccountResponse defines the response for Msg/MsgRegisterInterchainAccountResponse */
+export interface MsgRegisterInterchainAccountResponse {
+  channelId: string;
+}
+
+/** MsgSendTx defines the payload for Msg/SendTx */
+export interface MsgSendTx {
+  owner: string;
+  connectionId: string;
+  packetData:
+    | InterchainAccountPacketData
+    | undefined;
+  /**
+   * Relative timeout timestamp provided will be added to the current block time during transaction execution.
+   * The timeout timestamp must be non-zero.
+   */
+  relativeTimeout: number;
+}
+
+/** MsgSendTxResponse defines the response for MsgSendTx */
+export interface MsgSendTxResponse {
+  sequence: number;
+}
+
+function createBaseMsgRegisterInterchainAccount(): MsgRegisterInterchainAccount {
+  return { owner: "", connectionId: "", version: "" };
+}
+
+export const MsgRegisterInterchainAccount = {
+  encode(message: MsgRegisterInterchainAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.owner !== "") {
+      writer.uint32(10).string(message.owner);
+    }
+    if (message.connectionId !== "") {
+      writer.uint32(18).string(message.connectionId);
+    }
+    if (message.version !== "") {
+      writer.uint32(26).string(message.version);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRegisterInterchainAccount {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRegisterInterchainAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.owner = reader.string();
+          break;
+        case 2:
+          message.connectionId = reader.string();
+          break;
+        case 3:
+          message.version = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgRegisterInterchainAccount {
+    return {
+      owner: isSet(object.owner) ? String(object.owner) : "",
+      connectionId: isSet(object.connectionId) ? String(object.connectionId) : "",
+      version: isSet(object.version) ? String(object.version) : "",
+    };
+  },
+
+  toJSON(message: MsgRegisterInterchainAccount): unknown {
+    const obj: any = {};
+    message.owner !== undefined && (obj.owner = message.owner);
+    message.connectionId !== undefined && (obj.connectionId = message.connectionId);
+    message.version !== undefined && (obj.version = message.version);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MsgRegisterInterchainAccount>, I>>(object: I): MsgRegisterInterchainAccount {
+    const message = createBaseMsgRegisterInterchainAccount();
+    message.owner = object.owner ?? "";
+    message.connectionId = object.connectionId ?? "";
+    message.version = object.version ?? "";
+    return message;
+  },
+};
+
+function createBaseMsgRegisterInterchainAccountResponse(): MsgRegisterInterchainAccountResponse {
+  return { channelId: "" };
+}
+
+export const MsgRegisterInterchainAccountResponse = {
+  encode(message: MsgRegisterInterchainAccountResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.channelId !== "") {
+      writer.uint32(10).string(message.channelId);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgRegisterInterchainAccountResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgRegisterInterchainAccountResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.channelId = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgRegisterInterchainAccountResponse {
+    return { channelId: isSet(object.channelId) ? String(object.channelId) : "" };
+  },
+
+  toJSON(message: MsgRegisterInterchainAccountResponse): unknown {
+    const obj: any = {};
+    message.channelId !== undefined && (obj.channelId = message.channelId);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MsgRegisterInterchainAccountResponse>, I>>(
+    object: I,
+  ): MsgRegisterInterchainAccountResponse {
+    const message = createBaseMsgRegisterInterchainAccountResponse();
+    message.channelId = object.channelId ?? "";
+    return message;
+  },
+};
+
+function createBaseMsgSendTx(): MsgSendTx {
+  return { owner: "", connectionId: "", packetData: undefined, relativeTimeout: 0 };
+}
+
+export const MsgSendTx = {
+  encode(message: MsgSendTx, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.owner !== "") {
+      writer.uint32(10).string(message.owner);
+    }
+    if (message.connectionId !== "") {
+      writer.uint32(18).string(message.connectionId);
+    }
+    if (message.packetData !== undefined) {
+      InterchainAccountPacketData.encode(message.packetData, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.relativeTimeout !== 0) {
+      writer.uint32(32).uint64(message.relativeTimeout);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendTx {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSendTx();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.owner = reader.string();
+          break;
+        case 2:
+          message.connectionId = reader.string();
+          break;
+        case 3:
+          message.packetData = InterchainAccountPacketData.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.relativeTimeout = longToNumber(reader.uint64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSendTx {
+    return {
+      owner: isSet(object.owner) ? String(object.owner) : "",
+      connectionId: isSet(object.connectionId) ? String(object.connectionId) : "",
+      packetData: isSet(object.packetData) ? InterchainAccountPacketData.fromJSON(object.packetData) : undefined,
+      relativeTimeout: isSet(object.relativeTimeout) ? Number(object.relativeTimeout) : 0,
+    };
+  },
+
+  toJSON(message: MsgSendTx): unknown {
+    const obj: any = {};
+    message.owner !== undefined && (obj.owner = message.owner);
+    message.connectionId !== undefined && (obj.connectionId = message.connectionId);
+    message.packetData !== undefined
+      && (obj.packetData = message.packetData ? InterchainAccountPacketData.toJSON(message.packetData) : undefined);
+    message.relativeTimeout !== undefined && (obj.relativeTimeout = Math.round(message.relativeTimeout));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MsgSendTx>, I>>(object: I): MsgSendTx {
+    const message = createBaseMsgSendTx();
+    message.owner = object.owner ?? "";
+    message.connectionId = object.connectionId ?? "";
+    message.packetData = (object.packetData !== undefined && object.packetData !== null)
+      ? InterchainAccountPacketData.fromPartial(object.packetData)
+      : undefined;
+    message.relativeTimeout = object.relativeTimeout ?? 0;
+    return message;
+  },
+};
+
+function createBaseMsgSendTxResponse(): MsgSendTxResponse {
+  return { sequence: 0 };
+}
+
+export const MsgSendTxResponse = {
+  encode(message: MsgSendTxResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sequence !== 0) {
+      writer.uint32(8).uint64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendTxResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgSendTxResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.sequence = longToNumber(reader.uint64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgSendTxResponse {
+    return { sequence: isSet(object.sequence) ? Number(object.sequence) : 0 };
+  },
+
+  toJSON(message: MsgSendTxResponse): unknown {
+    const obj: any = {};
+    message.sequence !== undefined && (obj.sequence = Math.round(message.sequence));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MsgSendTxResponse>, I>>(object: I): MsgSendTxResponse {
+    const message = createBaseMsgSendTxResponse();
+    message.sequence = object.sequence ?? 0;
+    return message;
+  },
+};
+
+/** Msg defines the 27-interchain-accounts/controller Msg service. */
+export interface Msg {
+  /** RegisterInterchainAccount defines a rpc handler for MsgRegisterInterchainAccount. */
+  RegisterInterchainAccount(request: MsgRegisterInterchainAccount): Promise<MsgRegisterInterchainAccountResponse>;
+  /** SendTx defines a rpc handler for MsgSendTx. */
+  SendTx(request: MsgSendTx): Promise<MsgSendTxResponse>;
+}
+
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.RegisterInterchainAccount = this.RegisterInterchainAccount.bind(this);
+    this.SendTx = this.SendTx.bind(this);
+  }
+  RegisterInterchainAccount(request: MsgRegisterInterchainAccount): Promise<MsgRegisterInterchainAccountResponse> {
+    const data = MsgRegisterInterchainAccount.encode(request).finish();
+    const promise = this.rpc.request(
+      "ibc.applications.interchain_accounts.controller.v1.Msg",
+      "RegisterInterchainAccount",
+      data,
+    );
+    return promise.then((data) => MsgRegisterInterchainAccountResponse.decode(new _m0.Reader(data)));
+  }
+
+  SendTx(request: MsgSendTx): Promise<MsgSendTxResponse> {
+    const data = MsgSendTx.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.interchain_accounts.controller.v1.Msg", "SendTx", data);
+    return promise.then((data) => MsgSendTxResponse.decode(new _m0.Reader(data)));
+  }
+}
+
+interface Rpc {
+  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var globalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/ibc.applications.interchain_accounts.controller.v1/types/ibc/applications/interchain_accounts/v1/packet.ts

@@ -0,0 +1,234 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Any } from "../../../../google/protobuf/any";
+
+export const protobufPackage = "ibc.applications.interchain_accounts.v1";
+
+/**
+ * Type defines a classification of message issued from a controller chain to its associated interchain accounts
+ * host
+ */
+export enum Type {
+  /** TYPE_UNSPECIFIED - Default zero value enumeration */
+  TYPE_UNSPECIFIED = 0,
+  /** TYPE_EXECUTE_TX - Execute a transaction on an interchain accounts host chain */
+  TYPE_EXECUTE_TX = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function typeFromJSON(object: any): Type {
+  switch (object) {
+    case 0:
+    case "TYPE_UNSPECIFIED":
+      return Type.TYPE_UNSPECIFIED;
+    case 1:
+    case "TYPE_EXECUTE_TX":
+      return Type.TYPE_EXECUTE_TX;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Type.UNRECOGNIZED;
+  }
+}
+
+export function typeToJSON(object: Type): string {
+  switch (object) {
+    case Type.TYPE_UNSPECIFIED:
+      return "TYPE_UNSPECIFIED";
+    case Type.TYPE_EXECUTE_TX:
+      return "TYPE_EXECUTE_TX";
+    case Type.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** InterchainAccountPacketData is comprised of a raw transaction, type of transaction and optional memo field. */
+export interface InterchainAccountPacketData {
+  type: Type;
+  data: Uint8Array;
+  memo: string;
+}
+
+/** CosmosTx contains a list of sdk.Msg's. It should be used when sending transactions to an SDK host chain. */
+export interface CosmosTx {
+  messages: Any[];
+}
+
+function createBaseInterchainAccountPacketData(): InterchainAccountPacketData {
+  return { type: 0, data: new Uint8Array(), memo: "" };
+}
+
+export const InterchainAccountPacketData = {
+  encode(message: InterchainAccountPacketData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.type !== 0) {
+      writer.uint32(8).int32(message.type);
+    }
+    if (message.data.length !== 0) {
+      writer.uint32(18).bytes(message.data);
+    }
+    if (message.memo !== "") {
+      writer.uint32(26).string(message.memo);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): InterchainAccountPacketData {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInterchainAccountPacketData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.type = reader.int32() as any;
+          break;
+        case 2:
+          message.data = reader.bytes();
+          break;
+        case 3:
+          message.memo = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): InterchainAccountPacketData {
+    return {
+      type: isSet(object.type) ? typeFromJSON(object.type) : 0,
+      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
+      memo: isSet(object.memo) ? String(object.memo) : "",
+    };
+  },
+
+  toJSON(message: InterchainAccountPacketData): unknown {
+    const obj: any = {};
+    message.type !== undefined && (obj.type = typeToJSON(message.type));
+    message.data !== undefined
+      && (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+    message.memo !== undefined && (obj.memo = message.memo);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<InterchainAccountPacketData>, I>>(object: I): InterchainAccountPacketData {
+    const message = createBaseInterchainAccountPacketData();
+    message.type = object.type ?? 0;
+    message.data = object.data ?? new Uint8Array();
+    message.memo = object.memo ?? "";
+    return message;
+  },
+};
+
+function createBaseCosmosTx(): CosmosTx {
+  return { messages: [] };
+}
+
+export const CosmosTx = {
+  encode(message: CosmosTx, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.messages) {
+      Any.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CosmosTx {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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;
+  },
+
+  fromJSON(object: any): CosmosTx {
+    return { messages: Array.isArray(object?.messages) ? object.messages.map((e: any) => Any.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: CosmosTx): unknown {
+    const obj: any = {};
+    if (message.messages) {
+      obj.messages = message.messages.map((e) => e ? Any.toJSON(e) : undefined);
+    } else {
+      obj.messages = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<CosmosTx>, I>>(object: I): CosmosTx {
+    const message = createBaseCosmosTx();
+    message.messages = object.messages?.map((e) => Any.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var globalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/ibc.applications.transfer.v1/rest.ts

@@ -190,7 +190,13 @@ export interface V1Height {
 /**
  * MsgTransferResponse defines the Msg/Transfer response type.
  */
-export type V1MsgTransferResponse = object;
+export interface V1MsgTransferResponse {
+  /**
+   * sequence number of the transfer packet sent
+   * @format uint64
+   */
+  sequence?: string;
+}
 
 /**
 * QueryDenomHashResponse is the response type for the Query/DenomHash RPC