@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.11

package/esm/ibc/core/client/v1/tx.registry.js

@@ -0,0 +1,2 @@
+import { MsgCreateClient, MsgUpdateClient, MsgUpgradeClient, MsgSubmitMisbehaviour, MsgRecoverClient, MsgIBCSoftwareUpgrade, MsgUpdateParams } from "./tx";
+export const registry = [["/ibc.core.client.v1.MsgCreateClient", MsgCreateClient], ["/ibc.core.client.v1.MsgUpdateClient", MsgUpdateClient], ["/ibc.core.client.v1.MsgUpgradeClient", MsgUpgradeClient], ["/ibc.core.client.v1.MsgSubmitMisbehaviour", MsgSubmitMisbehaviour], ["/ibc.core.client.v1.MsgRecoverClient", MsgRecoverClient], ["/ibc.core.client.v1.MsgIBCSoftwareUpgrade", MsgIBCSoftwareUpgrade], ["/ibc.core.client.v1.MsgUpdateParams", MsgUpdateParams]];

package/esm/ibc/core/client/v1/tx.rpc.func.js

@@ -0,0 +1,52 @@
+import { buildTx } from "../../../../helper-func-types";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgCreateClient, MsgUpdateClient, MsgUpgradeClient, MsgSubmitMisbehaviour, MsgRecoverClient, MsgIBCSoftwareUpgrade, MsgUpdateParams } from "./tx";
+export const createCreateClient = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgCreateClient.typeUrl,
+    encoders: toEncoders(MsgCreateClient),
+    converters: toConverters(MsgCreateClient),
+    deps: [MsgCreateClient]
+});
+export const createUpdateClient = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgUpdateClient.typeUrl,
+    encoders: toEncoders(MsgUpdateClient),
+    converters: toConverters(MsgUpdateClient),
+    deps: [MsgUpdateClient]
+});
+export const createUpgradeClient = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgUpgradeClient.typeUrl,
+    encoders: toEncoders(MsgUpgradeClient),
+    converters: toConverters(MsgUpgradeClient),
+    deps: [MsgUpgradeClient]
+});
+export const createSubmitMisbehaviour = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgSubmitMisbehaviour.typeUrl,
+    encoders: toEncoders(MsgSubmitMisbehaviour),
+    converters: toConverters(MsgSubmitMisbehaviour),
+    deps: [MsgSubmitMisbehaviour]
+});
+export const createRecoverClient = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgRecoverClient.typeUrl,
+    encoders: toEncoders(MsgRecoverClient),
+    converters: toConverters(MsgRecoverClient),
+    deps: [MsgRecoverClient]
+});
+export const createIBCSoftwareUpgrade = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgIBCSoftwareUpgrade.typeUrl,
+    encoders: toEncoders(MsgIBCSoftwareUpgrade),
+    converters: toConverters(MsgIBCSoftwareUpgrade),
+    deps: [MsgIBCSoftwareUpgrade]
+});
+export const createUpdateClientParams = (clientResolver) => buildTx({
+    clientResolver,
+    typeUrl: MsgUpdateParams.typeUrl,
+    encoders: toEncoders(MsgUpdateParams),
+    converters: toConverters(MsgUpdateParams),
+    deps: [MsgUpdateParams]
+});

package/esm/ibc/core/client/v1/tx.rpc.react.js

@@ -0,0 +1,23 @@
+import { buildUseMutation } from "../../../../react-query";
+import { createCreateClient, createUpdateClient, createUpgradeClient, createSubmitMisbehaviour, createRecoverClient, createIBCSoftwareUpgrade, createUpdateClientParams } from "./tx.rpc.func";
+export const useCreateClient = buildUseMutation({
+    builderMutationFn: createCreateClient
+});
+export const useUpdateClient = buildUseMutation({
+    builderMutationFn: createUpdateClient
+});
+export const useUpgradeClient = buildUseMutation({
+    builderMutationFn: createUpgradeClient
+});
+export const useSubmitMisbehaviour = buildUseMutation({
+    builderMutationFn: createSubmitMisbehaviour
+});
+export const useRecoverClient = buildUseMutation({
+    builderMutationFn: createRecoverClient
+});
+export const useIBCSoftwareUpgrade = buildUseMutation({
+    builderMutationFn: createIBCSoftwareUpgrade
+});
+export const useUpdateClientParams = buildUseMutation({
+    builderMutationFn: createUpdateClientParams
+});

package/esm/ibc/core/commitment/v1/commitment.js

@@ -0,0 +1,319 @@
+import { CommitmentProof } from "../../../../cosmos/ics23/v1/proofs";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+function createBaseMerkleRoot() {
+    return {
+        hash: new Uint8Array()
+    };
+}
+export const MerkleRoot = {
+    typeUrl: "/ibc.core.commitment.v1.MerkleRoot",
+    aminoType: "cosmos-sdk/MerkleRoot",
+    is(o) {
+        return o && (o.$typeUrl === MerkleRoot.typeUrl || o.hash instanceof Uint8Array || typeof o.hash === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MerkleRoot.typeUrl || o.hash instanceof Uint8Array || typeof o.hash === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.hash.length !== 0) {
+            writer.uint32(10).bytes(message.hash);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMerkleRoot();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.hash = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMerkleRoot();
+        message.hash = object.hash ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMerkleRoot();
+        if (object.hash !== undefined && object.hash !== null) {
+            message.hash = bytesFromBase64(object.hash);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.hash = message.hash ? base64FromBytes(message.hash) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MerkleRoot.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MerkleRoot",
+            value: MerkleRoot.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MerkleRoot.decode(message.value);
+    },
+    toProto(message) {
+        return MerkleRoot.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.commitment.v1.MerkleRoot",
+            value: MerkleRoot.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseMerklePrefix() {
+    return {
+        keyPrefix: new Uint8Array()
+    };
+}
+export const MerklePrefix = {
+    typeUrl: "/ibc.core.commitment.v1.MerklePrefix",
+    aminoType: "cosmos-sdk/MerklePrefix",
+    is(o) {
+        return o && (o.$typeUrl === MerklePrefix.typeUrl || o.keyPrefix instanceof Uint8Array || typeof o.keyPrefix === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MerklePrefix.typeUrl || o.key_prefix instanceof Uint8Array || typeof o.key_prefix === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.keyPrefix.length !== 0) {
+            writer.uint32(10).bytes(message.keyPrefix);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMerklePrefix();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.keyPrefix = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMerklePrefix();
+        message.keyPrefix = object.keyPrefix ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMerklePrefix();
+        if (object.key_prefix !== undefined && object.key_prefix !== null) {
+            message.keyPrefix = bytesFromBase64(object.key_prefix);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key_prefix = message.keyPrefix ? base64FromBytes(message.keyPrefix) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MerklePrefix.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MerklePrefix",
+            value: MerklePrefix.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MerklePrefix.decode(message.value);
+    },
+    toProto(message) {
+        return MerklePrefix.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.commitment.v1.MerklePrefix",
+            value: MerklePrefix.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseMerklePath() {
+    return {
+        keyPath: []
+    };
+}
+export const MerklePath = {
+    typeUrl: "/ibc.core.commitment.v1.MerklePath",
+    aminoType: "cosmos-sdk/MerklePath",
+    is(o) {
+        return o && (o.$typeUrl === MerklePath.typeUrl || Array.isArray(o.keyPath) && (!o.keyPath.length || typeof o.keyPath[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MerklePath.typeUrl || Array.isArray(o.key_path) && (!o.key_path.length || typeof o.key_path[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.keyPath) {
+            writer.uint32(10).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMerklePath();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.keyPath.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMerklePath();
+        message.keyPath = object.keyPath?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMerklePath();
+        message.keyPath = object.key_path?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.keyPath) {
+            obj.key_path = message.keyPath.map(e => e);
+        }
+        else {
+            obj.key_path = message.keyPath;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MerklePath.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MerklePath",
+            value: MerklePath.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MerklePath.decode(message.value);
+    },
+    toProto(message) {
+        return MerklePath.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.commitment.v1.MerklePath",
+            value: MerklePath.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseMerkleProof() {
+    return {
+        proofs: []
+    };
+}
+export const MerkleProof = {
+    typeUrl: "/ibc.core.commitment.v1.MerkleProof",
+    aminoType: "cosmos-sdk/MerkleProof",
+    is(o) {
+        return o && (o.$typeUrl === MerkleProof.typeUrl || Array.isArray(o.proofs) && (!o.proofs.length || CommitmentProof.is(o.proofs[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MerkleProof.typeUrl || Array.isArray(o.proofs) && (!o.proofs.length || CommitmentProof.isAmino(o.proofs[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.proofs) {
+            CommitmentProof.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMerkleProof();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.proofs.push(CommitmentProof.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMerkleProof();
+        message.proofs = object.proofs?.map(e => CommitmentProof.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMerkleProof();
+        message.proofs = object.proofs?.map(e => CommitmentProof.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.proofs) {
+            obj.proofs = message.proofs.map(e => e ? CommitmentProof.toAmino(e) : undefined);
+        }
+        else {
+            obj.proofs = message.proofs;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MerkleProof.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MerkleProof",
+            value: MerkleProof.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MerkleProof.decode(message.value);
+    },
+    toProto(message) {
+        return MerkleProof.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.commitment.v1.MerkleProof",
+            value: MerkleProof.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        CommitmentProof.registerTypeUrl();
+    }
+};