carbon-js-sdk 0.3.52 → 0.3.53-dev.1

package/lib/codec/ibc/applications/interchain_accounts/controller/v1/tx.d.ts

@@ -0,0 +1,78 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { InterchainAccountPacketData } from "../../v1/packet";
+export declare 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;
+    /**
+     * Relative timeout timestamp provided will be added to the current block time during transaction execution.
+     * The timeout timestamp must be non-zero.
+     */
+    relativeTimeout: Long;
+}
+/** MsgSendTxResponse defines the response for MsgSendTx */
+export interface MsgSendTxResponse {
+    sequence: Long;
+}
+export declare const MsgRegisterInterchainAccount: {
+    encode(message: MsgRegisterInterchainAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgRegisterInterchainAccount;
+    fromJSON(object: any): MsgRegisterInterchainAccount;
+    toJSON(message: MsgRegisterInterchainAccount): unknown;
+    fromPartial(object: DeepPartial<MsgRegisterInterchainAccount>): MsgRegisterInterchainAccount;
+};
+export declare const MsgRegisterInterchainAccountResponse: {
+    encode(message: MsgRegisterInterchainAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgRegisterInterchainAccountResponse;
+    fromJSON(object: any): MsgRegisterInterchainAccountResponse;
+    toJSON(message: MsgRegisterInterchainAccountResponse): unknown;
+    fromPartial(object: DeepPartial<MsgRegisterInterchainAccountResponse>): MsgRegisterInterchainAccountResponse;
+};
+export declare const MsgSendTx: {
+    encode(message: MsgSendTx, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgSendTx;
+    fromJSON(object: any): MsgSendTx;
+    toJSON(message: MsgSendTx): unknown;
+    fromPartial(object: DeepPartial<MsgSendTx>): MsgSendTx;
+};
+export declare const MsgSendTxResponse: {
+    encode(message: MsgSendTxResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgSendTxResponse;
+    fromJSON(object: any): MsgSendTxResponse;
+    toJSON(message: MsgSendTxResponse): unknown;
+    fromPartial(object: DeepPartial<MsgSendTxResponse>): MsgSendTxResponse;
+};
+/** 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 declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    RegisterInterchainAccount(request: MsgRegisterInterchainAccount): Promise<MsgRegisterInterchainAccountResponse>;
+    SendTx(request: MsgSendTx): Promise<MsgSendTxResponse>;
+}
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+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/controller/v1/tx.js

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgClientImpl = exports.MsgSendTxResponse = exports.MsgSendTx = exports.MsgRegisterInterchainAccountResponse = exports.MsgRegisterInterchainAccount = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const packet_1 = require("../../v1/packet");
+exports.protobufPackage = "ibc.applications.interchain_accounts.controller.v1";
+const baseMsgRegisterInterchainAccount = {
+    owner: "",
+    connectionId: "",
+    version: "",
+};
+exports.MsgRegisterInterchainAccount = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        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, 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({}, baseMsgRegisterInterchainAccount);
+        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) {
+        const message = Object.assign({}, baseMsgRegisterInterchainAccount);
+        message.owner =
+            object.owner !== undefined && object.owner !== null
+                ? String(object.owner)
+                : "";
+        message.connectionId =
+            object.connectionId !== undefined && object.connectionId !== null
+                ? String(object.connectionId)
+                : "";
+        message.version =
+            object.version !== undefined && object.version !== null
+                ? String(object.version)
+                : "";
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.owner !== undefined && (obj.owner = message.owner);
+        message.connectionId !== undefined &&
+            (obj.connectionId = message.connectionId);
+        message.version !== undefined && (obj.version = message.version);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseMsgRegisterInterchainAccount);
+        message.owner = (_a = object.owner) !== null && _a !== void 0 ? _a : "";
+        message.connectionId = (_b = object.connectionId) !== null && _b !== void 0 ? _b : "";
+        message.version = (_c = object.version) !== null && _c !== void 0 ? _c : "";
+        return message;
+    },
+};
+const baseMsgRegisterInterchainAccountResponse = { channelId: "" };
+exports.MsgRegisterInterchainAccountResponse = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.channelId !== "") {
+            writer.uint32(10).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({}, baseMsgRegisterInterchainAccountResponse);
+        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) {
+        const message = Object.assign({}, baseMsgRegisterInterchainAccountResponse);
+        message.channelId =
+            object.channelId !== undefined && object.channelId !== null
+                ? String(object.channelId)
+                : "";
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.channelId !== undefined && (obj.channelId = message.channelId);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, baseMsgRegisterInterchainAccountResponse);
+        message.channelId = (_a = object.channelId) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
+const baseMsgSendTx = {
+    owner: "",
+    connectionId: "",
+    relativeTimeout: long_1.default.UZERO,
+};
+exports.MsgSendTx = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.connectionId !== "") {
+            writer.uint32(18).string(message.connectionId);
+        }
+        if (message.packetData !== undefined) {
+            packet_1.InterchainAccountPacketData.encode(message.packetData, writer.uint32(26).fork()).ldelim();
+        }
+        if (!message.relativeTimeout.isZero()) {
+            writer.uint32(32).uint64(message.relativeTimeout);
+        }
+        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({}, baseMsgSendTx);
+        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 = packet_1.InterchainAccountPacketData.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.relativeTimeout = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseMsgSendTx);
+        message.owner =
+            object.owner !== undefined && object.owner !== null
+                ? String(object.owner)
+                : "";
+        message.connectionId =
+            object.connectionId !== undefined && object.connectionId !== null
+                ? String(object.connectionId)
+                : "";
+        message.packetData =
+            object.packetData !== undefined && object.packetData !== null
+                ? packet_1.InterchainAccountPacketData.fromJSON(object.packetData)
+                : undefined;
+        message.relativeTimeout =
+            object.relativeTimeout !== undefined && object.relativeTimeout !== null
+                ? long_1.default.fromString(object.relativeTimeout)
+                : long_1.default.UZERO;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.owner !== undefined && (obj.owner = message.owner);
+        message.connectionId !== undefined &&
+            (obj.connectionId = message.connectionId);
+        message.packetData !== undefined &&
+            (obj.packetData = message.packetData
+                ? packet_1.InterchainAccountPacketData.toJSON(message.packetData)
+                : undefined);
+        message.relativeTimeout !== undefined &&
+            (obj.relativeTimeout = (message.relativeTimeout || long_1.default.UZERO).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = Object.assign({}, baseMsgSendTx);
+        message.owner = (_a = object.owner) !== null && _a !== void 0 ? _a : "";
+        message.connectionId = (_b = object.connectionId) !== null && _b !== void 0 ? _b : "";
+        message.packetData =
+            object.packetData !== undefined && object.packetData !== null
+                ? packet_1.InterchainAccountPacketData.fromPartial(object.packetData)
+                : undefined;
+        message.relativeTimeout =
+            object.relativeTimeout !== undefined && object.relativeTimeout !== null
+                ? long_1.default.fromValue(object.relativeTimeout)
+                : long_1.default.UZERO;
+        return message;
+    },
+};
+const baseMsgSendTxResponse = { sequence: long_1.default.UZERO };
+exports.MsgSendTxResponse = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (!message.sequence.isZero()) {
+            writer.uint32(8).uint64(message.sequence);
+        }
+        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({}, baseMsgSendTxResponse);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sequence = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseMsgSendTxResponse);
+        message.sequence =
+            object.sequence !== undefined && object.sequence !== null
+                ? long_1.default.fromString(object.sequence)
+                : long_1.default.UZERO;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.sequence !== undefined &&
+            (obj.sequence = (message.sequence || long_1.default.UZERO).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = Object.assign({}, baseMsgSendTxResponse);
+        message.sequence =
+            object.sequence !== undefined && object.sequence !== null
+                ? long_1.default.fromValue(object.sequence)
+                : long_1.default.UZERO;
+        return message;
+    },
+};
+class MsgClientImpl {
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.RegisterInterchainAccount = this.RegisterInterchainAccount.bind(this);
+        this.SendTx = this.SendTx.bind(this);
+    }
+    RegisterInterchainAccount(request) {
+        const data = exports.MsgRegisterInterchainAccount.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.interchain_accounts.controller.v1.Msg", "RegisterInterchainAccount", data);
+        return promise.then((data) => exports.MsgRegisterInterchainAccountResponse.decode(new minimal_1.default.Reader(data)));
+    }
+    SendTx(request) {
+        const data = exports.MsgSendTx.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.interchain_accounts.controller.v1.Msg", "SendTx", data);
+        return promise.then((data) => exports.MsgSendTxResponse.decode(new minimal_1.default.Reader(data)));
+    }
+}
+exports.MsgClientImpl = MsgClientImpl;
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

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

@@ -0,0 +1,80 @@
+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.genesis.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, as well as a boolean flag to
+ * indicate if the channel is middleware enabled
+ */
+export interface ActiveChannel {
+    connectionId: string;
+    portId: string;
+    channelId: string;
+    isMiddlewareEnabled: boolean;
+}
+/** 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 {};