carbon-js-sdk 0.5.11 → 0.5.12

package/lib/clients/GrpcNodeQueryClient.d.ts

@@ -0,0 +1,12 @@
+import { GrpcQueryClient } from "../util/type";
+import * as grpc from "@grpc/grpc-js";
+export declare class GrpcNodeQueryClient implements GrpcQueryClient {
+    private host;
+    private options;
+    private client;
+    constructor(host: string, options?: {
+        metadata?: grpc.Metadata;
+    });
+    request(serviceName: string, methodName: string, data: Uint8Array): Promise<Uint8Array>;
+}
+export default GrpcNodeQueryClient;

package/lib/clients/GrpcNodeQueryClient.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcNodeQueryClient = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const PASS_THROUGH_SERIALIZE = (bytes) => Buffer.from(bytes);
+const PASS_THROUGH_DESERIALIZE = (buffer) => new Uint8Array(buffer);
+class GrpcNodeQueryClient {
+    constructor(host, options = {}) {
+        this.host = host;
+        this.options = options;
+        this.client = new grpc.Client(this.host, grpc.credentials.createSsl());
+    }
+    request(serviceName, methodName, data) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            const method = `/${serviceName}/${methodName}`;
+            const metadata = (_a = this.options.metadata) !== null && _a !== void 0 ? _a : grpc.Metadata.fromHttp2Headers({});
+            this.client.makeUnaryRequest(method, PASS_THROUGH_SERIALIZE, PASS_THROUGH_DESERIALIZE, data, metadata, (error, result) => {
+                if (error || !result) {
+                    reject(error);
+                }
+                else {
+                    resolve(result);
+                }
+            });
+        });
+    }
+}
+exports.GrpcNodeQueryClient = GrpcNodeQueryClient;
+exports.default = GrpcNodeQueryClient;

package/lib/clients/GrpcQueryClient.d.ts

@@ -7,7 +7,7 @@ export declare class GrpcWebError extends Error {
 }
 /**
  * Uses grpc-web module on cosmos-sdk to simulate gRPC queries
- * throught HTTP/1.1.
+ * through HTTP/1.1.
  * see https://github.com/cosmos/cosmos-sdk/issues/7345
  */
 export declare class GrpcQueryClient implements ProtobufRpcClient {

package/lib/clients/GrpcQueryClient.js

@@ -12,7 +12,7 @@ class GrpcWebError extends Error {
 exports.GrpcWebError = GrpcWebError;
 /**
  * Uses grpc-web module on cosmos-sdk to simulate gRPC queries
- * throught HTTP/1.1.
+ * through HTTP/1.1.
  * see https://github.com/cosmos/cosmos-sdk/issues/7345
  */
 class GrpcQueryClient {

package/lib/clients/GrpcWebQueryClient.d.ts

@@ -0,0 +1,22 @@
+import { GrpcQueryClient } from "../util/type";
+import { grpc } from "@improbable-eng/grpc-web";
+export declare class GrpcWebError extends Error {
+    code: grpc.Code;
+    metadata: grpc.Metadata;
+    constructor(message: string, code: grpc.Code, metadata: grpc.Metadata);
+}
+/**
+ * Uses grpc-web module on cosmos-sdk to simulate gRPC queries
+ * through HTTP/1.1.
+ * see https://github.com/cosmos/cosmos-sdk/issues/7345
+ */
+export declare class GrpcWebQueryClient implements GrpcQueryClient {
+    private host;
+    private options;
+    constructor(host: string, options?: {
+        transport?: grpc.TransportFactory;
+        metadata?: grpc.Metadata;
+    });
+    request(serviceName: string, methodName: string, data: Uint8Array): Promise<Uint8Array>;
+}
+export default GrpcWebQueryClient;

package/lib/clients/GrpcWebQueryClient.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcWebQueryClient = exports.GrpcWebError = void 0;
+const grpc_web_1 = require("@improbable-eng/grpc-web");
+class GrpcWebError extends Error {
+    constructor(message, code, metadata) {
+        super(message);
+        this.code = code;
+        this.metadata = metadata;
+    }
+}
+exports.GrpcWebError = GrpcWebError;
+/**
+ * Uses grpc-web module on cosmos-sdk to simulate gRPC queries
+ * through HTTP/1.1.
+ * see https://github.com/cosmos/cosmos-sdk/issues/7345
+ */
+class GrpcWebQueryClient {
+    constructor(host, options = {}) {
+        this.host = host;
+        this.options = options;
+    }
+    request(serviceName, methodName, data) {
+        return new Promise((resolve, reject) => {
+            grpc_web_1.grpc.unary({
+                methodName,
+                service: { serviceName },
+                requestStream: false,
+                responseStream: false,
+                requestType: {},
+                responseType: {
+                    deserializeBinary: (data) => data,
+                },
+            }, {
+                request: Object.assign(Object.assign({}, data), { toObject: () => data, serializeBinary: () => data }),
+                host: this.host,
+                metadata: this.options.metadata,
+                transport: this.options.transport,
+                debug: false,
+                onEnd: function (response) {
+                    if (response.status === grpc_web_1.grpc.Code.OK) {
+                        resolve(response.message);
+                    }
+                    else {
+                        const err = new Error(response.statusMessage);
+                        err.code = response.status;
+                        err.metadata = response.trailers;
+                        reject(err);
+                    }
+                },
+            });
+        });
+    }
+}
+exports.GrpcWebQueryClient = GrpcWebQueryClient;
+exports.default = GrpcWebQueryClient;

package/lib/codec/ibc/applications/interchain_accounts/v1/genesis.d.ts

@@ -0,0 +1,76 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { Params } from "../controller/v1/controller";
+import { Params as Params1 } from "../host/v1/host";
+export declare const protobufPackage = "ibc.applications.interchain_accounts.v1";
+/** GenesisState defines the interchain accounts genesis state */
+export interface GenesisState {
+    controllerGenesisState?: ControllerGenesisState;
+    hostGenesisState?: HostGenesisState;
+}
+/** ControllerGenesisState defines the interchain accounts controller genesis state */
+export interface ControllerGenesisState {
+    activeChannels: ActiveChannel[];
+    interchainAccounts: RegisteredInterchainAccount[];
+    ports: string[];
+    params?: Params;
+}
+/** HostGenesisState defines the interchain accounts host genesis state */
+export interface HostGenesisState {
+    activeChannels: ActiveChannel[];
+    interchainAccounts: RegisteredInterchainAccount[];
+    port: string;
+    params?: Params1;
+}
+/** ActiveChannel contains a connection ID, port ID and associated active channel ID */
+export interface ActiveChannel {
+    connectionId: string;
+    portId: string;
+    channelId: string;
+}
+/** RegisteredInterchainAccount contains a connection ID, port ID and associated interchain account address */
+export interface RegisteredInterchainAccount {
+    connectionId: string;
+    portId: string;
+    accountAddress: string;
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};
+export declare const ControllerGenesisState: {
+    encode(message: ControllerGenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ControllerGenesisState;
+    fromJSON(object: any): ControllerGenesisState;
+    toJSON(message: ControllerGenesisState): unknown;
+    fromPartial(object: DeepPartial<ControllerGenesisState>): ControllerGenesisState;
+};
+export declare const HostGenesisState: {
+    encode(message: HostGenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): HostGenesisState;
+    fromJSON(object: any): HostGenesisState;
+    toJSON(message: HostGenesisState): unknown;
+    fromPartial(object: DeepPartial<HostGenesisState>): HostGenesisState;
+};
+export declare const ActiveChannel: {
+    encode(message: ActiveChannel, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ActiveChannel;
+    fromJSON(object: any): ActiveChannel;
+    toJSON(message: ActiveChannel): unknown;
+    fromPartial(object: DeepPartial<ActiveChannel>): ActiveChannel;
+};
+export declare const RegisteredInterchainAccount: {
+    encode(message: RegisteredInterchainAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): RegisteredInterchainAccount;
+    fromJSON(object: any): RegisteredInterchainAccount;
+    toJSON(message: RegisteredInterchainAccount): unknown;
+    fromPartial(object: DeepPartial<RegisteredInterchainAccount>): RegisteredInterchainAccount;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : 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>;
+export {};

package/lib/codec/ibc/applications/interchain_accounts/v1/genesis.js

@@ -0,0 +1,424 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisteredInterchainAccount = exports.ActiveChannel = exports.HostGenesisState = exports.ControllerGenesisState = exports.GenesisState = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const controller_1 = require("../controller/v1/controller");
+const host_1 = require("../host/v1/host");
+exports.protobufPackage = "ibc.applications.interchain_accounts.v1";
+const baseGenesisState = {};
+exports.GenesisState = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.controllerGenesisState !== undefined) {
+            exports.ControllerGenesisState.encode(message.controllerGenesisState, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.hostGenesisState !== undefined) {
+            exports.HostGenesisState.encode(message.hostGenesisState, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseGenesisState);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.controllerGenesisState = exports.ControllerGenesisState.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.hostGenesisState = exports.HostGenesisState.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseGenesisState);
+        message.controllerGenesisState =
+            object.controllerGenesisState !== undefined &&
+                object.controllerGenesisState !== null
+                ? exports.ControllerGenesisState.fromJSON(object.controllerGenesisState)
+                : undefined;
+        message.hostGenesisState =
+            object.hostGenesisState !== undefined && object.hostGenesisState !== null
+                ? exports.HostGenesisState.fromJSON(object.hostGenesisState)
+                : undefined;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.controllerGenesisState !== undefined &&
+            (obj.controllerGenesisState = message.controllerGenesisState
+                ? exports.ControllerGenesisState.toJSON(message.controllerGenesisState)
+                : undefined);
+        message.hostGenesisState !== undefined &&
+            (obj.hostGenesisState = message.hostGenesisState
+                ? exports.HostGenesisState.toJSON(message.hostGenesisState)
+                : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = Object.assign({}, baseGenesisState);
+        message.controllerGenesisState =
+            object.controllerGenesisState !== undefined &&
+                object.controllerGenesisState !== null
+                ? exports.ControllerGenesisState.fromPartial(object.controllerGenesisState)
+                : undefined;
+        message.hostGenesisState =
+            object.hostGenesisState !== undefined && object.hostGenesisState !== null
+                ? exports.HostGenesisState.fromPartial(object.hostGenesisState)
+                : undefined;
+        return message;
+    },
+};
+const baseControllerGenesisState = { ports: "" };
+exports.ControllerGenesisState = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        for (const v of message.activeChannels) {
+            exports.ActiveChannel.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.interchainAccounts) {
+            exports.RegisteredInterchainAccount.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.ports) {
+            writer.uint32(26).string(v);
+        }
+        if (message.params !== undefined) {
+            controller_1.Params.encode(message.params, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseControllerGenesisState);
+        message.activeChannels = [];
+        message.interchainAccounts = [];
+        message.ports = [];
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.activeChannels.push(exports.ActiveChannel.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.interchainAccounts.push(exports.RegisteredInterchainAccount.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.ports.push(reader.string());
+                    break;
+                case 4:
+                    message.params = controller_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseControllerGenesisState);
+        message.activeChannels = ((_a = object.activeChannels) !== null && _a !== void 0 ? _a : []).map((e) => exports.ActiveChannel.fromJSON(e));
+        message.interchainAccounts = ((_b = object.interchainAccounts) !== null && _b !== void 0 ? _b : []).map((e) => exports.RegisteredInterchainAccount.fromJSON(e));
+        message.ports = ((_c = object.ports) !== null && _c !== void 0 ? _c : []).map((e) => String(e));
+        message.params =
+            object.params !== undefined && object.params !== null
+                ? controller_1.Params.fromJSON(object.params)
+                : undefined;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.activeChannels) {
+            obj.activeChannels = message.activeChannels.map((e) => e ? exports.ActiveChannel.toJSON(e) : undefined);
+        }
+        else {
+            obj.activeChannels = [];
+        }
+        if (message.interchainAccounts) {
+            obj.interchainAccounts = message.interchainAccounts.map((e) => e ? exports.RegisteredInterchainAccount.toJSON(e) : undefined);
+        }
+        else {
+            obj.interchainAccounts = [];
+        }
+        if (message.ports) {
+            obj.ports = message.ports.map((e) => e);
+        }
+        else {
+            obj.ports = [];
+        }
+        message.params !== undefined &&
+            (obj.params = message.params ? controller_1.Params.toJSON(message.params) : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseControllerGenesisState);
+        message.activeChannels = ((_a = object.activeChannels) !== null && _a !== void 0 ? _a : []).map((e) => exports.ActiveChannel.fromPartial(e));
+        message.interchainAccounts = ((_b = object.interchainAccounts) !== null && _b !== void 0 ? _b : []).map((e) => exports.RegisteredInterchainAccount.fromPartial(e));
+        message.ports = ((_c = object.ports) !== null && _c !== void 0 ? _c : []).map((e) => e);
+        message.params =
+            object.params !== undefined && object.params !== null
+                ? controller_1.Params.fromPartial(object.params)
+                : undefined;
+        return message;
+    },
+};
+const baseHostGenesisState = { port: "" };
+exports.HostGenesisState = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        for (const v of message.activeChannels) {
+            exports.ActiveChannel.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.interchainAccounts) {
+            exports.RegisteredInterchainAccount.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.port !== "") {
+            writer.uint32(26).string(message.port);
+        }
+        if (message.params !== undefined) {
+            host_1.Params.encode(message.params, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseHostGenesisState);
+        message.activeChannels = [];
+        message.interchainAccounts = [];
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.activeChannels.push(exports.ActiveChannel.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.interchainAccounts.push(exports.RegisteredInterchainAccount.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.port = reader.string();
+                    break;
+                case 4:
+                    message.params = host_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        var _a, _b;
+        const message = Object.assign({}, baseHostGenesisState);
+        message.activeChannels = ((_a = object.activeChannels) !== null && _a !== void 0 ? _a : []).map((e) => exports.ActiveChannel.fromJSON(e));
+        message.interchainAccounts = ((_b = object.interchainAccounts) !== null && _b !== void 0 ? _b : []).map((e) => exports.RegisteredInterchainAccount.fromJSON(e));
+        message.port =
+            object.port !== undefined && object.port !== null
+                ? String(object.port)
+                : "";
+        message.params =
+            object.params !== undefined && object.params !== null
+                ? host_1.Params.fromJSON(object.params)
+                : undefined;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.activeChannels) {
+            obj.activeChannels = message.activeChannels.map((e) => e ? exports.ActiveChannel.toJSON(e) : undefined);
+        }
+        else {
+            obj.activeChannels = [];
+        }
+        if (message.interchainAccounts) {
+            obj.interchainAccounts = message.interchainAccounts.map((e) => e ? exports.RegisteredInterchainAccount.toJSON(e) : undefined);
+        }
+        else {
+            obj.interchainAccounts = [];
+        }
+        message.port !== undefined && (obj.port = message.port);
+        message.params !== undefined &&
+            (obj.params = message.params
+                ? host_1.Params.toJSON(message.params)
+                : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseHostGenesisState);
+        message.activeChannels = ((_a = object.activeChannels) !== null && _a !== void 0 ? _a : []).map((e) => exports.ActiveChannel.fromPartial(e));
+        message.interchainAccounts = ((_b = object.interchainAccounts) !== null && _b !== void 0 ? _b : []).map((e) => exports.RegisteredInterchainAccount.fromPartial(e));
+        message.port = (_c = object.port) !== null && _c !== void 0 ? _c : "";
+        message.params =
+            object.params !== undefined && object.params !== null
+                ? host_1.Params.fromPartial(object.params)
+                : undefined;
+        return message;
+    },
+};
+const baseActiveChannel = {
+    connectionId: "",
+    portId: "",
+    channelId: "",
+};
+exports.ActiveChannel = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.connectionId !== "") {
+            writer.uint32(10).string(message.connectionId);
+        }
+        if (message.portId !== "") {
+            writer.uint32(18).string(message.portId);
+        }
+        if (message.channelId !== "") {
+            writer.uint32(26).string(message.channelId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseActiveChannel);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.connectionId = reader.string();
+                    break;
+                case 2:
+                    message.portId = reader.string();
+                    break;
+                case 3:
+                    message.channelId = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseActiveChannel);
+        message.connectionId =
+            object.connectionId !== undefined && object.connectionId !== null
+                ? String(object.connectionId)
+                : "";
+        message.portId =
+            object.portId !== undefined && object.portId !== null
+                ? String(object.portId)
+                : "";
+        message.channelId =
+            object.channelId !== undefined && object.channelId !== null
+                ? String(object.channelId)
+                : "";
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.connectionId !== undefined &&
+            (obj.connectionId = message.connectionId);
+        message.portId !== undefined && (obj.portId = message.portId);
+        message.channelId !== undefined && (obj.channelId = message.channelId);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseActiveChannel);
+        message.connectionId = (_a = object.connectionId) !== null && _a !== void 0 ? _a : "";
+        message.portId = (_b = object.portId) !== null && _b !== void 0 ? _b : "";
+        message.channelId = (_c = object.channelId) !== null && _c !== void 0 ? _c : "";
+        return message;
+    },
+};
+const baseRegisteredInterchainAccount = {
+    connectionId: "",
+    portId: "",
+    accountAddress: "",
+};
+exports.RegisteredInterchainAccount = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.connectionId !== "") {
+            writer.uint32(10).string(message.connectionId);
+        }
+        if (message.portId !== "") {
+            writer.uint32(18).string(message.portId);
+        }
+        if (message.accountAddress !== "") {
+            writer.uint32(26).string(message.accountAddress);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseRegisteredInterchainAccount);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.connectionId = reader.string();
+                    break;
+                case 2:
+                    message.portId = reader.string();
+                    break;
+                case 3:
+                    message.accountAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseRegisteredInterchainAccount);
+        message.connectionId =
+            object.connectionId !== undefined && object.connectionId !== null
+                ? String(object.connectionId)
+                : "";
+        message.portId =
+            object.portId !== undefined && object.portId !== null
+                ? String(object.portId)
+                : "";
+        message.accountAddress =
+            object.accountAddress !== undefined && object.accountAddress !== null
+                ? String(object.accountAddress)
+                : "";
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.connectionId !== undefined &&
+            (obj.connectionId = message.connectionId);
+        message.portId !== undefined && (obj.portId = message.portId);
+        message.accountAddress !== undefined &&
+            (obj.accountAddress = message.accountAddress);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseRegisteredInterchainAccount);
+        message.connectionId = (_a = object.connectionId) !== null && _a !== void 0 ? _a : "";
+        message.portId = (_b = object.portId) !== null && _b !== void 0 ? _b : "";
+        message.accountAddress = (_c = object.accountAddress) !== null && _c !== void 0 ? _c : "";
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/constant/network.js

@@ -333,6 +333,6 @@ exports.NetworkConfigs = {
     },
 };
 exports.publicRpcNodes = {
-    Osmosis: "https://rpc.osmosis.zone/",
+    Osmosis: "https://osmosis-rpc.polkachu.com/",
     Terra: "https://terra-rpc.lavenderfive.com:443/",
 };

package/lib/provider/amino/types/erc20.js

@@ -34,7 +34,7 @@ const MsgConvertCoin = {
     valueMap: {},
 };
 const ERC20Amino = {
-    [CarbonTx.Types.MsgConvertERC20]: utils_1.generateAminoType(MsgConvertERC20),
-    [CarbonTx.Types.MsgConvertCoin]: utils_1.generateAminoType(MsgConvertCoin),
+    [CarbonTx.Types.MsgConvertERC20]: (0, utils_1.generateAminoType)(MsgConvertERC20),
+    [CarbonTx.Types.MsgConvertCoin]: (0, utils_1.generateAminoType)(MsgConvertCoin),
 };
 exports.default = ERC20Amino;

package/lib/provider/amino/types/perpsliquidity.js

@@ -63,11 +63,11 @@ const MsgWithdrawFromPlPool = {
     },
 };
 const PerpsliquidityAmino = {
-    [CarbonTx.Types.MsgCreatePlPool]: utils_1.generateAminoType(MsgCreatePlPool),
-    [CarbonTx.Types.MsgUpdatePlPool]: utils_1.generateAminoType(MsgUpdatePlPool),
-    [CarbonTx.Types.MsgRegisterToPlPool]: utils_1.generateAminoType(MsgRegisterToPlPool),
-    [CarbonTx.Types.MsgDeregisterFromPlPool]: utils_1.generateAminoType(MsgDeregisterFromPlPool),
-    [CarbonTx.Types.MsgDepositToPlPool]: utils_1.generateAminoType(MsgDepositToPlPool),
-    [CarbonTx.Types.MsgWithdrawFromPlPool]: utils_1.generateAminoType(MsgWithdrawFromPlPool),
+    [CarbonTx.Types.MsgCreatePlPool]: (0, utils_1.generateAminoType)(MsgCreatePlPool),
+    [CarbonTx.Types.MsgUpdatePlPool]: (0, utils_1.generateAminoType)(MsgUpdatePlPool),
+    [CarbonTx.Types.MsgRegisterToPlPool]: (0, utils_1.generateAminoType)(MsgRegisterToPlPool),
+    [CarbonTx.Types.MsgDeregisterFromPlPool]: (0, utils_1.generateAminoType)(MsgDeregisterFromPlPool),
+    [CarbonTx.Types.MsgDepositToPlPool]: (0, utils_1.generateAminoType)(MsgDepositToPlPool),
+    [CarbonTx.Types.MsgWithdrawFromPlPool]: (0, utils_1.generateAminoType)(MsgWithdrawFromPlPool),
 };
 exports.default = PerpsliquidityAmino;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carbon-js-sdk",
-  "version": "0.5.11",
+  "version": "0.5.12",
   "description": "TypeScript SDK for Carbon blockchain",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",