@iconlake/client 0.0.1

package/cosmos.base.tendermint.v1beta1/types/tendermint/types/validator.ts

@@ -0,0 +1,308 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { PublicKey } from "../crypto/keys";
+
+export const protobufPackage = "tendermint.types";
+
+export interface ValidatorSet {
+  validators: Validator[];
+  proposer: Validator | undefined;
+  totalVotingPower: number;
+}
+
+export interface Validator {
+  address: Uint8Array;
+  pubKey: PublicKey | undefined;
+  votingPower: number;
+  proposerPriority: number;
+}
+
+export interface SimpleValidator {
+  pubKey: PublicKey | undefined;
+  votingPower: number;
+}
+
+function createBaseValidatorSet(): ValidatorSet {
+  return { validators: [], proposer: undefined, totalVotingPower: 0 };
+}
+
+export const ValidatorSet = {
+  encode(message: ValidatorSet, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.validators) {
+      Validator.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.proposer !== undefined) {
+      Validator.encode(message.proposer, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.totalVotingPower !== 0) {
+      writer.uint32(24).int64(message.totalVotingPower);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ValidatorSet {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseValidatorSet();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.validators.push(Validator.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.proposer = Validator.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.totalVotingPower = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ValidatorSet {
+    return {
+      validators: Array.isArray(object?.validators) ? object.validators.map((e: any) => Validator.fromJSON(e)) : [],
+      proposer: isSet(object.proposer) ? Validator.fromJSON(object.proposer) : undefined,
+      totalVotingPower: isSet(object.totalVotingPower) ? Number(object.totalVotingPower) : 0,
+    };
+  },
+
+  toJSON(message: ValidatorSet): unknown {
+    const obj: any = {};
+    if (message.validators) {
+      obj.validators = message.validators.map((e) => e ? Validator.toJSON(e) : undefined);
+    } else {
+      obj.validators = [];
+    }
+    message.proposer !== undefined
+      && (obj.proposer = message.proposer ? Validator.toJSON(message.proposer) : undefined);
+    message.totalVotingPower !== undefined && (obj.totalVotingPower = Math.round(message.totalVotingPower));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ValidatorSet>, I>>(object: I): ValidatorSet {
+    const message = createBaseValidatorSet();
+    message.validators = object.validators?.map((e) => Validator.fromPartial(e)) || [];
+    message.proposer = (object.proposer !== undefined && object.proposer !== null)
+      ? Validator.fromPartial(object.proposer)
+      : undefined;
+    message.totalVotingPower = object.totalVotingPower ?? 0;
+    return message;
+  },
+};
+
+function createBaseValidator(): Validator {
+  return { address: new Uint8Array(), pubKey: undefined, votingPower: 0, proposerPriority: 0 };
+}
+
+export const Validator = {
+  encode(message: Validator, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address.length !== 0) {
+      writer.uint32(10).bytes(message.address);
+    }
+    if (message.pubKey !== undefined) {
+      PublicKey.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.votingPower !== 0) {
+      writer.uint32(24).int64(message.votingPower);
+    }
+    if (message.proposerPriority !== 0) {
+      writer.uint32(32).int64(message.proposerPriority);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Validator {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseValidator();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.bytes();
+          break;
+        case 2:
+          message.pubKey = PublicKey.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.votingPower = longToNumber(reader.int64() as Long);
+          break;
+        case 4:
+          message.proposerPriority = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Validator {
+    return {
+      address: isSet(object.address) ? bytesFromBase64(object.address) : new Uint8Array(),
+      pubKey: isSet(object.pubKey) ? PublicKey.fromJSON(object.pubKey) : undefined,
+      votingPower: isSet(object.votingPower) ? Number(object.votingPower) : 0,
+      proposerPriority: isSet(object.proposerPriority) ? Number(object.proposerPriority) : 0,
+    };
+  },
+
+  toJSON(message: Validator): unknown {
+    const obj: any = {};
+    message.address !== undefined
+      && (obj.address = base64FromBytes(message.address !== undefined ? message.address : new Uint8Array()));
+    message.pubKey !== undefined && (obj.pubKey = message.pubKey ? PublicKey.toJSON(message.pubKey) : undefined);
+    message.votingPower !== undefined && (obj.votingPower = Math.round(message.votingPower));
+    message.proposerPriority !== undefined && (obj.proposerPriority = Math.round(message.proposerPriority));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Validator>, I>>(object: I): Validator {
+    const message = createBaseValidator();
+    message.address = object.address ?? new Uint8Array();
+    message.pubKey = (object.pubKey !== undefined && object.pubKey !== null)
+      ? PublicKey.fromPartial(object.pubKey)
+      : undefined;
+    message.votingPower = object.votingPower ?? 0;
+    message.proposerPriority = object.proposerPriority ?? 0;
+    return message;
+  },
+};
+
+function createBaseSimpleValidator(): SimpleValidator {
+  return { pubKey: undefined, votingPower: 0 };
+}
+
+export const SimpleValidator = {
+  encode(message: SimpleValidator, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pubKey !== undefined) {
+      PublicKey.encode(message.pubKey, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.votingPower !== 0) {
+      writer.uint32(16).int64(message.votingPower);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SimpleValidator {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSimpleValidator();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.pubKey = PublicKey.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.votingPower = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SimpleValidator {
+    return {
+      pubKey: isSet(object.pubKey) ? PublicKey.fromJSON(object.pubKey) : undefined,
+      votingPower: isSet(object.votingPower) ? Number(object.votingPower) : 0,
+    };
+  },
+
+  toJSON(message: SimpleValidator): unknown {
+    const obj: any = {};
+    message.pubKey !== undefined && (obj.pubKey = message.pubKey ? PublicKey.toJSON(message.pubKey) : undefined);
+    message.votingPower !== undefined && (obj.votingPower = Math.round(message.votingPower));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SimpleValidator>, I>>(object: I): SimpleValidator {
+    const message = createBaseSimpleValidator();
+    message.pubKey = (object.pubKey !== undefined && object.pubKey !== null)
+      ? PublicKey.fromPartial(object.pubKey)
+      : undefined;
+    message.votingPower = object.votingPower ?? 0;
+    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 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/cosmos.base.tendermint.v1beta1/types/tendermint/version/types.ts

@@ -0,0 +1,184 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "tendermint.version";
+
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ */
+export interface App {
+  protocol: number;
+  software: string;
+}
+
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ */
+export interface Consensus {
+  block: number;
+  app: number;
+}
+
+function createBaseApp(): App {
+  return { protocol: 0, software: "" };
+}
+
+export const App = {
+  encode(message: App, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.protocol !== 0) {
+      writer.uint32(8).uint64(message.protocol);
+    }
+    if (message.software !== "") {
+      writer.uint32(18).string(message.software);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): App {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseApp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.protocol = longToNumber(reader.uint64() as Long);
+          break;
+        case 2:
+          message.software = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): App {
+    return {
+      protocol: isSet(object.protocol) ? Number(object.protocol) : 0,
+      software: isSet(object.software) ? String(object.software) : "",
+    };
+  },
+
+  toJSON(message: App): unknown {
+    const obj: any = {};
+    message.protocol !== undefined && (obj.protocol = Math.round(message.protocol));
+    message.software !== undefined && (obj.software = message.software);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<App>, I>>(object: I): App {
+    const message = createBaseApp();
+    message.protocol = object.protocol ?? 0;
+    message.software = object.software ?? "";
+    return message;
+  },
+};
+
+function createBaseConsensus(): Consensus {
+  return { block: 0, app: 0 };
+}
+
+export const Consensus = {
+  encode(message: Consensus, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.block !== 0) {
+      writer.uint32(8).uint64(message.block);
+    }
+    if (message.app !== 0) {
+      writer.uint32(16).uint64(message.app);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Consensus {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConsensus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.block = longToNumber(reader.uint64() as Long);
+          break;
+        case 2:
+          message.app = longToNumber(reader.uint64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Consensus {
+    return { block: isSet(object.block) ? Number(object.block) : 0, app: isSet(object.app) ? Number(object.app) : 0 };
+  },
+
+  toJSON(message: Consensus): unknown {
+    const obj: any = {};
+    message.block !== undefined && (obj.block = Math.round(message.block));
+    message.app !== undefined && (obj.app = Math.round(message.app));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Consensus>, I>>(object: I): Consensus {
+    const message = createBaseConsensus();
+    message.block = object.block ?? 0;
+    message.app = object.app ?? 0;
+    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";
+})();
+
+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/cosmos.base.tendermint.v1beta1/types.ts

@@ -0,0 +1,19 @@
+import { Validator } from "./types/cosmos/base/tendermint/v1beta1/query"
+import { VersionInfo } from "./types/cosmos/base/tendermint/v1beta1/query"
+import { Module } from "./types/cosmos/base/tendermint/v1beta1/query"
+import { ProofOp } from "./types/cosmos/base/tendermint/v1beta1/query"
+import { ProofOps } from "./types/cosmos/base/tendermint/v1beta1/query"
+import { Block } from "./types/cosmos/base/tendermint/v1beta1/types"
+import { Header } from "./types/cosmos/base/tendermint/v1beta1/types"
+
+
+export {     
+    Validator,
+    VersionInfo,
+    Module,
+    ProofOp,
+    ProofOps,
+    Block,
+    Header,
+    
+ }

package/cosmos.crisis.v1beta1/index.ts

@@ -0,0 +1,6 @@
+import Module from './module';
+import { txClient, queryClient, registry } from './module';
+import { msgTypes } from './registry';
+
+export * from "./types";
+export { Module, msgTypes, txClient, queryClient, registry };

package/cosmos.crisis.v1beta1/module.ts

@@ -0,0 +1,129 @@
+// Generated by Ignite ignite.com/cli
+
+import { StdFee } from "@cosmjs/launchpad";
+import { SigningStargateClient, DeliverTxResponse } from "@cosmjs/stargate";
+import { EncodeObject, GeneratedType, OfflineSigner, Registry } from "@cosmjs/proto-signing";
+import { msgTypes } from './registry';
+import { IgniteClient } from "../client"
+import { MissingWalletError } from "../helpers"
+import { Api } from "./rest";
+import { MsgVerifyInvariant } from "./types/cosmos/crisis/v1beta1/tx";
+
+
+export { MsgVerifyInvariant };
+
+type sendMsgVerifyInvariantParams = {
+  value: MsgVerifyInvariant,
+  fee?: StdFee,
+  memo?: string
+};
+
+
+type msgVerifyInvariantParams = {
+  value: MsgVerifyInvariant,
+};
+
+
+export const registry = new Registry(msgTypes);
+
+type Field = {
+	name: string;
+	type: unknown;
+}
+function getStructure(template) {
+	const structure: {fields: Field[]} = { fields: [] }
+	for (let [key, value] of Object.entries(template)) {
+		let field = { name: key, type: typeof value }
+		structure.fields.push(field)
+	}
+	return structure
+}
+const defaultFee = {
+  amount: [],
+  gas: "200000",
+};
+
+interface TxClientOptions {
+  addr: string
+	prefix: string
+	signer?: OfflineSigner
+}
+
+export const txClient = ({ signer, prefix, addr }: TxClientOptions = { addr: "http://localhost:26657", prefix: "cosmos" }) => {
+
+  return {
+		
+		async sendMsgVerifyInvariant({ value, fee, memo }: sendMsgVerifyInvariantParams): Promise<DeliverTxResponse> {
+			if (!signer) {
+					throw new Error('TxClient:sendMsgVerifyInvariant: Unable to sign Tx. Signer is not present.')
+			}
+			try {			
+				const { address } = (await signer.getAccounts())[0]; 
+				const signingClient = await SigningStargateClient.connectWithSigner(addr,signer,{registry, prefix});
+				let msg = this.msgVerifyInvariant({ value: MsgVerifyInvariant.fromPartial(value) })
+				return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo)
+			} catch (e: any) {
+				throw new Error('TxClient:sendMsgVerifyInvariant: Could not broadcast Tx: '+ e.message)
+			}
+		},
+		
+		
+		msgVerifyInvariant({ value }: msgVerifyInvariantParams): EncodeObject {
+			try {
+				return { typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant", value: MsgVerifyInvariant.fromPartial( value ) }  
+			} catch (e: any) {
+				throw new Error('TxClient:MsgVerifyInvariant: Could not create message: ' + e.message)
+			}
+		},
+		
+	}
+};
+
+interface QueryClientOptions {
+  addr: string
+}
+
+export const queryClient = ({ addr: addr }: QueryClientOptions = { addr: "http://localhost:1317" }) => {
+  return new Api({ baseURL: addr });
+};
+
+class SDKModule {
+	public query: ReturnType<typeof queryClient>;
+	public tx: ReturnType<typeof txClient>;
+	public structure: Record<string,unknown>;
+	public registry: Array<[string, GeneratedType]> = [];
+
+	constructor(client: IgniteClient) {		
+	
+		this.query = queryClient({ addr: client.env.apiURL });		
+		this.updateTX(client);
+		this.structure =  {
+						
+		};
+		client.on('signer-changed',(signer) => {			
+		 this.updateTX(client);
+		})
+	}
+	updateTX(client: IgniteClient) {
+    const methods = txClient({
+        signer: client.signer,
+        addr: client.env.rpcURL,
+        prefix: client.env.prefix ?? "cosmos",
+    })
+	
+    this.tx = methods;
+    for (let m in methods) {
+        this.tx[m] = methods[m].bind(this.tx);
+    }
+	}
+};
+
+const Module = (test: IgniteClient) => {
+	return {
+		module: {
+			CosmosCrisisV1Beta1: new SDKModule(test)
+		},
+		registry: msgTypes
+  }
+}
+export default Module;

package/cosmos.crisis.v1beta1/registry.ts

@@ -0,0 +1,9 @@
+import { GeneratedType } from "@cosmjs/proto-signing";
+import { MsgVerifyInvariant } from "./types/cosmos/crisis/v1beta1/tx";
+
+const msgTypes: Array<[string, GeneratedType]>  = [
+    ["/cosmos.crisis.v1beta1.MsgVerifyInvariant", MsgVerifyInvariant],
+    
+];
+
+export { msgTypes }