decentralcardgame-cardchain-client-ts 0.0.3 → 0.0.4

package/cosmos.staking.v1beta1/module.js

@@ -3,12 +3,12 @@ import { SigningStargateClient } from "@cosmjs/stargate";
 import { Registry } from "@cosmjs/proto-signing";
 import { msgTypes } from './registry';
 import { Api } from "./rest";
-import { MsgCreateValidator } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgCancelUnbondingDelegation } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgUndelegate } from "./types/cosmos/staking/v1beta1/tx";
 import { MsgDelegate } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgEditValidator } from "./types/cosmos/staking/v1beta1/tx";
 import { MsgBeginRedelegate } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgUndelegate } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgEditValidator } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgCreateValidator } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgCancelUnbondingDelegation } from "./types/cosmos/staking/v1beta1/tx";
 import { StakeAuthorization as typeStakeAuthorization } from "./types";
 import { StakeAuthorization_Validators as typeStakeAuthorization_Validators } from "./types";
 import { LastValidatorPower as typeLastValidatorPower } from "./types";
@@ -32,7 +32,7 @@ import { DelegationResponse as typeDelegationResponse } from "./types";
 import { RedelegationEntryResponse as typeRedelegationEntryResponse } from "./types";
 import { RedelegationResponse as typeRedelegationResponse } from "./types";
 import { Pool as typePool } from "./types";
-export { MsgCreateValidator, MsgCancelUnbondingDelegation, MsgDelegate, MsgEditValidator, MsgBeginRedelegate, MsgUndelegate };
+export { MsgUndelegate, MsgDelegate, MsgBeginRedelegate, MsgEditValidator, MsgCreateValidator, MsgCancelUnbondingDelegation };
 export const registry = new Registry(msgTypes);
 function getStructure(template) {
     const structure = { fields: [] };
@@ -48,46 +48,46 @@ const defaultFee = {
 };
 export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26657", prefix: "cosmos" }) => {
     return {
-        async sendMsgCreateValidator({ value, fee, memo }) {
+        async sendMsgUndelegate({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateValidator: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgUndelegate: 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.msgCreateValidator({ value: MsgCreateValidator.fromPartial(value) });
+                let msg = this.msgUndelegate({ value: MsgUndelegate.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgCreateValidator: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgUndelegate: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgCancelUnbondingDelegation({ value, fee, memo }) {
+        async sendMsgDelegate({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCancelUnbondingDelegation: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgDelegate: 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.msgCancelUnbondingDelegation({ value: MsgCancelUnbondingDelegation.fromPartial(value) });
+                let msg = this.msgDelegate({ value: MsgDelegate.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgCancelUnbondingDelegation: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgDelegate: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgDelegate({ value, fee, memo }) {
+        async sendMsgBeginRedelegate({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgDelegate: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgBeginRedelegate: 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.msgDelegate({ value: MsgDelegate.fromPartial(value) });
+                let msg = this.msgBeginRedelegate({ value: MsgBeginRedelegate.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgDelegate: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgBeginRedelegate: Could not broadcast Tx: ' + e.message);
             }
         },
         async sendMsgEditValidator({ value, fee, memo }) {
@@ -104,56 +104,56 @@ export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26
                 throw new Error('TxClient:sendMsgEditValidator: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgBeginRedelegate({ value, fee, memo }) {
+        async sendMsgCreateValidator({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgBeginRedelegate: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgCreateValidator: 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.msgBeginRedelegate({ value: MsgBeginRedelegate.fromPartial(value) });
+                let msg = this.msgCreateValidator({ value: MsgCreateValidator.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgBeginRedelegate: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgCreateValidator: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgUndelegate({ value, fee, memo }) {
+        async sendMsgCancelUnbondingDelegation({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgUndelegate: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgCancelUnbondingDelegation: 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.msgUndelegate({ value: MsgUndelegate.fromPartial(value) });
+                let msg = this.msgCancelUnbondingDelegation({ value: MsgCancelUnbondingDelegation.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgUndelegate: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgCancelUnbondingDelegation: Could not broadcast Tx: ' + e.message);
             }
         },
-        msgCreateValidator({ value }) {
+        msgUndelegate({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgCreateValidator", value: MsgCreateValidator.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate", value: MsgUndelegate.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgCreateValidator: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgUndelegate: Could not create message: ' + e.message);
             }
         },
-        msgCancelUnbondingDelegation({ value }) {
+        msgDelegate({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", value: MsgCancelUnbondingDelegation.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgDelegate", value: MsgDelegate.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgCancelUnbondingDelegation: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgDelegate: Could not create message: ' + e.message);
             }
         },
-        msgDelegate({ value }) {
+        msgBeginRedelegate({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgDelegate", value: MsgDelegate.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate", value: MsgBeginRedelegate.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgDelegate: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgBeginRedelegate: Could not create message: ' + e.message);
             }
         },
         msgEditValidator({ value }) {
@@ -164,20 +164,20 @@ export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26
                 throw new Error('TxClient:MsgEditValidator: Could not create message: ' + e.message);
             }
         },
-        msgBeginRedelegate({ value }) {
+        msgCreateValidator({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate", value: MsgBeginRedelegate.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgCreateValidator", value: MsgCreateValidator.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgBeginRedelegate: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgCreateValidator: Could not create message: ' + e.message);
             }
         },
-        msgUndelegate({ value }) {
+        msgCancelUnbondingDelegation({ value }) {
             try {
-                return { typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate", value: MsgUndelegate.fromPartial(value) };
+                return { typeUrl: "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", value: MsgCancelUnbondingDelegation.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgUndelegate: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgCancelUnbondingDelegation: Could not create message: ' + e.message);
             }
         },
     };

package/cosmos.staking.v1beta1/registry.js

@@ -1,15 +1,15 @@
-import { MsgCreateValidator } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgCancelUnbondingDelegation } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgUndelegate } from "./types/cosmos/staking/v1beta1/tx";
 import { MsgDelegate } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgEditValidator } from "./types/cosmos/staking/v1beta1/tx";
 import { MsgBeginRedelegate } from "./types/cosmos/staking/v1beta1/tx";
-import { MsgUndelegate } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgEditValidator } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgCreateValidator } from "./types/cosmos/staking/v1beta1/tx";
+import { MsgCancelUnbondingDelegation } from "./types/cosmos/staking/v1beta1/tx";
 const msgTypes = [
-    ["/cosmos.staking.v1beta1.MsgCreateValidator", MsgCreateValidator],
-    ["/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", MsgCancelUnbondingDelegation],
+    ["/cosmos.staking.v1beta1.MsgUndelegate", MsgUndelegate],
     ["/cosmos.staking.v1beta1.MsgDelegate", MsgDelegate],
-    ["/cosmos.staking.v1beta1.MsgEditValidator", MsgEditValidator],
     ["/cosmos.staking.v1beta1.MsgBeginRedelegate", MsgBeginRedelegate],
-    ["/cosmos.staking.v1beta1.MsgUndelegate", MsgUndelegate],
+    ["/cosmos.staking.v1beta1.MsgEditValidator", MsgEditValidator],
+    ["/cosmos.staking.v1beta1.MsgCreateValidator", MsgCreateValidator],
+    ["/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", MsgCancelUnbondingDelegation],
 ];
 export { msgTypes };

package/cosmos.vesting.v1beta1/module.js

@@ -3,8 +3,8 @@ import { SigningStargateClient } from "@cosmjs/stargate";
 import { Registry } from "@cosmjs/proto-signing";
 import { msgTypes } from './registry';
 import { Api } from "./rest";
-import { MsgCreateVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { MsgCreatePermanentLockedAccount } from "./types/cosmos/vesting/v1beta1/tx";
+import { MsgCreateVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { MsgCreatePeriodicVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { BaseVestingAccount as typeBaseVestingAccount } from "./types";
 import { ContinuousVestingAccount as typeContinuousVestingAccount } from "./types";
@@ -12,7 +12,7 @@ import { DelayedVestingAccount as typeDelayedVestingAccount } from "./types";
 import { Period as typePeriod } from "./types";
 import { PeriodicVestingAccount as typePeriodicVestingAccount } from "./types";
 import { PermanentLockedAccount as typePermanentLockedAccount } from "./types";
-export { MsgCreateVestingAccount, MsgCreatePermanentLockedAccount, MsgCreatePeriodicVestingAccount };
+export { MsgCreatePermanentLockedAccount, MsgCreateVestingAccount, MsgCreatePeriodicVestingAccount };
 export const registry = new Registry(msgTypes);
 function getStructure(template) {
     const structure = { fields: [] };
@@ -28,32 +28,32 @@ const defaultFee = {
 };
 export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26657", prefix: "cosmos" }) => {
     return {
-        async sendMsgCreateVestingAccount({ value, fee, memo }) {
+        async sendMsgCreatePermanentLockedAccount({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreateVestingAccount: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgCreatePermanentLockedAccount: 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.msgCreateVestingAccount({ value: MsgCreateVestingAccount.fromPartial(value) });
+                let msg = this.msgCreatePermanentLockedAccount({ value: MsgCreatePermanentLockedAccount.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgCreateVestingAccount: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgCreatePermanentLockedAccount: Could not broadcast Tx: ' + e.message);
             }
         },
-        async sendMsgCreatePermanentLockedAccount({ value, fee, memo }) {
+        async sendMsgCreateVestingAccount({ value, fee, memo }) {
             if (!signer) {
-                throw new Error('TxClient:sendMsgCreatePermanentLockedAccount: Unable to sign Tx. Signer is not present.');
+                throw new Error('TxClient:sendMsgCreateVestingAccount: 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.msgCreatePermanentLockedAccount({ value: MsgCreatePermanentLockedAccount.fromPartial(value) });
+                let msg = this.msgCreateVestingAccount({ value: MsgCreateVestingAccount.fromPartial(value) });
                 return await signingClient.signAndBroadcast(address, [msg], fee ? fee : defaultFee, memo);
             }
             catch (e) {
-                throw new Error('TxClient:sendMsgCreatePermanentLockedAccount: Could not broadcast Tx: ' + e.message);
+                throw new Error('TxClient:sendMsgCreateVestingAccount: Could not broadcast Tx: ' + e.message);
             }
         },
         async sendMsgCreatePeriodicVestingAccount({ value, fee, memo }) {
@@ -70,20 +70,20 @@ export const txClient = ({ signer, prefix, addr } = { addr: "http://localhost:26
                 throw new Error('TxClient:sendMsgCreatePeriodicVestingAccount: Could not broadcast Tx: ' + e.message);
             }
         },
-        msgCreateVestingAccount({ value }) {
+        msgCreatePermanentLockedAccount({ value }) {
             try {
-                return { typeUrl: "/cosmos.vesting.v1beta1.MsgCreateVestingAccount", value: MsgCreateVestingAccount.fromPartial(value) };
+                return { typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount", value: MsgCreatePermanentLockedAccount.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgCreateVestingAccount: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgCreatePermanentLockedAccount: Could not create message: ' + e.message);
             }
         },
-        msgCreatePermanentLockedAccount({ value }) {
+        msgCreateVestingAccount({ value }) {
             try {
-                return { typeUrl: "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount", value: MsgCreatePermanentLockedAccount.fromPartial(value) };
+                return { typeUrl: "/cosmos.vesting.v1beta1.MsgCreateVestingAccount", value: MsgCreateVestingAccount.fromPartial(value) };
             }
             catch (e) {
-                throw new Error('TxClient:MsgCreatePermanentLockedAccount: Could not create message: ' + e.message);
+                throw new Error('TxClient:MsgCreateVestingAccount: Could not create message: ' + e.message);
             }
         },
         msgCreatePeriodicVestingAccount({ value }) {

package/cosmos.vesting.v1beta1/registry.js

@@ -1,9 +1,9 @@
-import { MsgCreateVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { MsgCreatePermanentLockedAccount } from "./types/cosmos/vesting/v1beta1/tx";
+import { MsgCreateVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 import { MsgCreatePeriodicVestingAccount } from "./types/cosmos/vesting/v1beta1/tx";
 const msgTypes = [
-    ["/cosmos.vesting.v1beta1.MsgCreateVestingAccount", MsgCreateVestingAccount],
     ["/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount", MsgCreatePermanentLockedAccount],
+    ["/cosmos.vesting.v1beta1.MsgCreateVestingAccount", MsgCreateVestingAccount],
     ["/cosmos.vesting.v1beta1.MsgCreatePeriodicVestingAccount", MsgCreatePeriodicVestingAccount],
 ];
 export { msgTypes };

package/ibc.applications.interchain_accounts.controller.v1/rest.js

@@ -8,6 +8,15 @@
  * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
  * ---------------------------------------------------------------
  */
+/**
+* - TYPE_UNSPECIFIED: Default zero value enumeration
+ - TYPE_EXECUTE_TX: Execute a transaction on an interchain accounts host chain
+*/
+export var InterchainAccountsv1Type;
+(function (InterchainAccountsv1Type) {
+    InterchainAccountsv1Type["TYPE_UNSPECIFIED"] = "TYPE_UNSPECIFIED";
+    InterchainAccountsv1Type["TYPE_EXECUTE_TX"] = "TYPE_EXECUTE_TX";
+})(InterchainAccountsv1Type || (InterchainAccountsv1Type = {}));
 import axios from "axios";
 export var ContentType;
 (function (ContentType) {

package/ibc.applications.interchain_accounts.controller.v1/types/google/protobuf/any.js

@@ -0,0 +1,99 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+export const protobufPackage = "google.protobuf";
+function createBaseAny() {
+    return { typeUrl: "", value: new Uint8Array() };
+}
+export const Any = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.typeUrl !== "") {
+            writer.uint32(10).string(message.typeUrl);
+        }
+        if (message.value.length !== 0) {
+            writer.uint32(18).bytes(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAny();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.typeUrl = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            typeUrl: isSet(object.typeUrl) ? String(object.typeUrl) : "",
+            value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.typeUrl !== undefined && (obj.typeUrl = message.typeUrl);
+        message.value !== undefined
+            && (obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseAny();
+        message.typeUrl = object.typeUrl ?? "";
+        message.value = object.value ?? new Uint8Array();
+        return message;
+    },
+};
+var globalThis = (() => {
+    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) {
+    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) {
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(""));
+    }
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}