@gitopia/gitopiajs 0.0.2

package/dist/gitopia/client.js

@@ -0,0 +1,70 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSigningGitopiaClient = exports.getSigningGitopiaClientOptions = exports.gitopiaProtoRegistry = exports.gitopiaAminoConverters = void 0;
+//@ts-nocheck
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const stargate_1 = require("@cosmjs/stargate");
+const gitopiaGitopiaGitopiaTxRegistry = __importStar(require("./gitopia/gitopia/tx.registry"));
+const gitopiaGitopiaRewardsTxRegistry = __importStar(require("./gitopia/rewards/tx.registry"));
+const gitopiaGitopiaGitopiaTxAmino = __importStar(require("./gitopia/gitopia/tx.amino"));
+const gitopiaGitopiaRewardsTxAmino = __importStar(require("./gitopia/rewards/tx.amino"));
+exports.gitopiaAminoConverters = {
+    ...gitopiaGitopiaGitopiaTxAmino.AminoConverter,
+    ...gitopiaGitopiaRewardsTxAmino.AminoConverter
+};
+exports.gitopiaProtoRegistry = [...gitopiaGitopiaGitopiaTxRegistry.registry, ...gitopiaGitopiaRewardsTxRegistry.registry];
+const getSigningGitopiaClientOptions = ({ defaultTypes = stargate_1.defaultRegistryTypes } = {}) => {
+    const registry = new proto_signing_1.Registry([...defaultTypes, ...exports.gitopiaProtoRegistry]);
+    const aminoTypes = new stargate_1.AminoTypes({
+        ...exports.gitopiaAminoConverters
+    });
+    return {
+        registry,
+        aminoTypes
+    };
+};
+exports.getSigningGitopiaClientOptions = getSigningGitopiaClientOptions;
+const getSigningGitopiaClient = async ({ rpcEndpoint, signer, defaultTypes = stargate_1.defaultRegistryTypes }) => {
+    const { registry, aminoTypes } = (0, exports.getSigningGitopiaClientOptions)({
+        defaultTypes
+    });
+    const client = await stargate_1.SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+        registry: registry,
+        aminoTypes
+    });
+    return client;
+};
+exports.getSigningGitopiaClient = getSigningGitopiaClient;

package/dist/gitopia/custom-lcd-client.d.ts

@@ -0,0 +1,31 @@
+export declare const createCustomLCDClient: ({ restEndpoint }: {
+    restEndpoint: string;
+}) => Promise<{
+    cosmos: {
+        bank: {
+            v1beta1: import("../cosmos/bank/v1beta1/query.lcd").LCDQueryClient;
+        };
+        feegrant: {
+            v1beta1: import("../cosmos/feegrant/v1beta1/query.lcd").LCDQueryClient;
+        };
+        gov: {
+            v1beta1: import("../cosmos/gov/v1beta1/query.lcd").LCDQueryClient;
+        };
+        group: {
+            v1: import("../cosmos/group/v1/query.lcd").LCDQueryClient;
+        };
+    };
+    gitopia: {
+        gitopia: {
+            gitopia: import("./gitopia/gitopia/query.lcd").LCDQueryClient;
+            rewards: import("./gitopia/rewards/query.lcd").LCDQueryClient;
+        };
+    };
+    ibc: {
+        applications: {
+            transfer: {
+                v1: import("../ibc/applications/transfer/v1/query.lcd").LCDQueryClient;
+            };
+        };
+    };
+}>;

package/dist/gitopia/custom-lcd-client.js

@@ -0,0 +1,87 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCustomLCDClient = void 0;
+//@ts-nocheck
+const lcd_1 = require("@cosmology/lcd");
+const createCustomLCDClient = async ({ restEndpoint }) => {
+    const requestClient = new lcd_1.LCDClient({
+        restEndpoint
+    });
+    return {
+        cosmos: {
+            bank: {
+                v1beta1: new (await Promise.resolve().then(() => __importStar(require("../cosmos/bank/v1beta1/query.lcd")))).LCDQueryClient({
+                    requestClient
+                })
+            },
+            feegrant: {
+                v1beta1: new (await Promise.resolve().then(() => __importStar(require("../cosmos/feegrant/v1beta1/query.lcd")))).LCDQueryClient({
+                    requestClient
+                })
+            },
+            gov: {
+                v1beta1: new (await Promise.resolve().then(() => __importStar(require("../cosmos/gov/v1beta1/query.lcd")))).LCDQueryClient({
+                    requestClient
+                })
+            },
+            group: {
+                v1: new (await Promise.resolve().then(() => __importStar(require("../cosmos/group/v1/query.lcd")))).LCDQueryClient({
+                    requestClient
+                })
+            }
+        },
+        gitopia: {
+            gitopia: {
+                gitopia: new (await Promise.resolve().then(() => __importStar(require("./gitopia/gitopia/query.lcd")))).LCDQueryClient({
+                    requestClient
+                }),
+                rewards: new (await Promise.resolve().then(() => __importStar(require("./gitopia/rewards/query.lcd")))).LCDQueryClient({
+                    requestClient
+                })
+            }
+        },
+        ibc: {
+            applications: {
+                transfer: {
+                    v1: new (await Promise.resolve().then(() => __importStar(require("../ibc/applications/transfer/v1/query.lcd")))).LCDQueryClient({
+                        requestClient
+                    })
+                }
+            }
+        }
+    };
+};
+exports.createCustomLCDClient = createCustomLCDClient;

package/dist/gitopia/gitopia/gitopia/attachment.d.ts

@@ -0,0 +1,39 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+export interface Attachment {
+    name: string;
+    size: bigint;
+    sha: string;
+    uploader: string;
+}
+export interface AttachmentProtoMsg {
+    typeUrl: "/gitopia.gitopia.gitopia.Attachment";
+    value: Uint8Array;
+}
+export interface AttachmentAmino {
+    name?: string;
+    size?: string;
+    sha?: string;
+    uploader?: string;
+}
+export interface AttachmentAminoMsg {
+    type: "/gitopia.gitopia.gitopia.Attachment";
+    value: AttachmentAmino;
+}
+export interface AttachmentSDKType {
+    name: string;
+    size: bigint;
+    sha: string;
+    uploader: string;
+}
+export declare const Attachment: {
+    typeUrl: string;
+    encode(message: Attachment, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Attachment;
+    fromPartial(object: Partial<Attachment>): Attachment;
+    fromAmino(object: AttachmentAmino): Attachment;
+    toAmino(message: Attachment): AttachmentAmino;
+    fromAminoMsg(object: AttachmentAminoMsg): Attachment;
+    fromProtoMsg(message: AttachmentProtoMsg): Attachment;
+    toProto(message: Attachment): Uint8Array;
+    toProtoMsg(message: Attachment): AttachmentProtoMsg;
+};

package/dist/gitopia/gitopia/gitopia/attachment.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attachment = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseAttachment() {
+    return {
+        name: "",
+        size: BigInt(0),
+        sha: "",
+        uploader: ""
+    };
+}
+exports.Attachment = {
+    typeUrl: "/gitopia.gitopia.gitopia.Attachment",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.size !== BigInt(0)) {
+            writer.uint32(16).uint64(message.size);
+        }
+        if (message.sha !== "") {
+            writer.uint32(26).string(message.sha);
+        }
+        if (message.uploader !== "") {
+            writer.uint32(34).string(message.uploader);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAttachment();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.size = reader.uint64();
+                    break;
+                case 3:
+                    message.sha = reader.string();
+                    break;
+                case 4:
+                    message.uploader = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAttachment();
+        message.name = object.name ?? "";
+        message.size = object.size !== undefined && object.size !== null ? BigInt(object.size.toString()) : BigInt(0);
+        message.sha = object.sha ?? "";
+        message.uploader = object.uploader ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAttachment();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.size !== undefined && object.size !== null) {
+            message.size = BigInt(object.size);
+        }
+        if (object.sha !== undefined && object.sha !== null) {
+            message.sha = object.sha;
+        }
+        if (object.uploader !== undefined && object.uploader !== null) {
+            message.uploader = object.uploader;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.size = message.size !== BigInt(0) ? message.size?.toString() : undefined;
+        obj.sha = message.sha === "" ? undefined : message.sha;
+        obj.uploader = message.uploader === "" ? undefined : message.uploader;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Attachment.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Attachment.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Attachment.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.Attachment",
+            value: exports.Attachment.encode(message).finish()
+        };
+    }
+};

package/dist/gitopia/gitopia/gitopia/bounty.d.ts

@@ -0,0 +1,79 @@
+import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+export declare enum BountyState {
+    BOUNTY_STATE_SRCDEBITTED = 0,
+    BOUNTY_STATE_DESTCREDITED = 1,
+    BOUNTY_STATE_REVERTEDBACK = 2,
+    UNRECOGNIZED = -1
+}
+export declare const BountyStateSDKType: typeof BountyState;
+export declare const BountyStateAmino: typeof BountyState;
+export declare function bountyStateFromJSON(object: any): BountyState;
+export declare function bountyStateToJSON(object: BountyState): string;
+export declare enum BountyParent {
+    BOUNTY_PARENT_ISSUE = 0,
+    UNRECOGNIZED = -1
+}
+export declare const BountyParentSDKType: typeof BountyParent;
+export declare const BountyParentAmino: typeof BountyParent;
+export declare function bountyParentFromJSON(object: any): BountyParent;
+export declare function bountyParentToJSON(object: BountyParent): string;
+export interface Bounty {
+    id: bigint;
+    amount: Coin[];
+    state: BountyState;
+    repositoryId: bigint;
+    parentIid: bigint;
+    parent: BountyParent;
+    expireAt: bigint;
+    rewardedTo: string;
+    createdAt: bigint;
+    updatedAt: bigint;
+    creator: string;
+}
+export interface BountyProtoMsg {
+    typeUrl: "/gitopia.gitopia.gitopia.Bounty";
+    value: Uint8Array;
+}
+export interface BountyAmino {
+    id?: string;
+    amount?: CoinAmino[];
+    state?: BountyState;
+    repositoryId?: string;
+    parentIid?: string;
+    parent?: BountyParent;
+    expireAt?: string;
+    rewardedTo?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    creator?: string;
+}
+export interface BountyAminoMsg {
+    type: "/gitopia.gitopia.gitopia.Bounty";
+    value: BountyAmino;
+}
+export interface BountySDKType {
+    id: bigint;
+    amount: CoinSDKType[];
+    state: BountyState;
+    repositoryId: bigint;
+    parentIid: bigint;
+    parent: BountyParent;
+    expireAt: bigint;
+    rewardedTo: string;
+    createdAt: bigint;
+    updatedAt: bigint;
+    creator: string;
+}
+export declare const Bounty: {
+    typeUrl: string;
+    encode(message: Bounty, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Bounty;
+    fromPartial(object: Partial<Bounty>): Bounty;
+    fromAmino(object: BountyAmino): Bounty;
+    toAmino(message: Bounty): BountyAmino;
+    fromAminoMsg(object: BountyAminoMsg): Bounty;
+    fromProtoMsg(message: BountyProtoMsg): Bounty;
+    toProto(message: Bounty): Uint8Array;
+    toProtoMsg(message: Bounty): BountyProtoMsg;
+};

package/dist/gitopia/gitopia/gitopia/bounty.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bounty = exports.BountyParentAmino = exports.BountyParentSDKType = exports.BountyParent = exports.BountyStateAmino = exports.BountyStateSDKType = exports.BountyState = void 0;
+exports.bountyStateFromJSON = bountyStateFromJSON;
+exports.bountyStateToJSON = bountyStateToJSON;
+exports.bountyParentFromJSON = bountyParentFromJSON;
+exports.bountyParentToJSON = bountyParentToJSON;
+//@ts-nocheck
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
+const binary_1 = require("../../../binary");
+var BountyState;
+(function (BountyState) {
+    BountyState[BountyState["BOUNTY_STATE_SRCDEBITTED"] = 0] = "BOUNTY_STATE_SRCDEBITTED";
+    BountyState[BountyState["BOUNTY_STATE_DESTCREDITED"] = 1] = "BOUNTY_STATE_DESTCREDITED";
+    BountyState[BountyState["BOUNTY_STATE_REVERTEDBACK"] = 2] = "BOUNTY_STATE_REVERTEDBACK";
+    BountyState[BountyState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(BountyState || (exports.BountyState = BountyState = {}));
+exports.BountyStateSDKType = BountyState;
+exports.BountyStateAmino = BountyState;
+function bountyStateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "BOUNTY_STATE_SRCDEBITTED":
+            return BountyState.BOUNTY_STATE_SRCDEBITTED;
+        case 1:
+        case "BOUNTY_STATE_DESTCREDITED":
+            return BountyState.BOUNTY_STATE_DESTCREDITED;
+        case 2:
+        case "BOUNTY_STATE_REVERTEDBACK":
+            return BountyState.BOUNTY_STATE_REVERTEDBACK;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return BountyState.UNRECOGNIZED;
+    }
+}
+function bountyStateToJSON(object) {
+    switch (object) {
+        case BountyState.BOUNTY_STATE_SRCDEBITTED:
+            return "BOUNTY_STATE_SRCDEBITTED";
+        case BountyState.BOUNTY_STATE_DESTCREDITED:
+            return "BOUNTY_STATE_DESTCREDITED";
+        case BountyState.BOUNTY_STATE_REVERTEDBACK:
+            return "BOUNTY_STATE_REVERTEDBACK";
+        case BountyState.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+var BountyParent;
+(function (BountyParent) {
+    BountyParent[BountyParent["BOUNTY_PARENT_ISSUE"] = 0] = "BOUNTY_PARENT_ISSUE";
+    BountyParent[BountyParent["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(BountyParent || (exports.BountyParent = BountyParent = {}));
+exports.BountyParentSDKType = BountyParent;
+exports.BountyParentAmino = BountyParent;
+function bountyParentFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "BOUNTY_PARENT_ISSUE":
+            return BountyParent.BOUNTY_PARENT_ISSUE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return BountyParent.UNRECOGNIZED;
+    }
+}
+function bountyParentToJSON(object) {
+    switch (object) {
+        case BountyParent.BOUNTY_PARENT_ISSUE:
+            return "BOUNTY_PARENT_ISSUE";
+        case BountyParent.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseBounty() {
+    return {
+        id: BigInt(0),
+        amount: [],
+        state: 0,
+        repositoryId: BigInt(0),
+        parentIid: BigInt(0),
+        parent: 0,
+        expireAt: BigInt(0),
+        rewardedTo: "",
+        createdAt: BigInt(0),
+        updatedAt: BigInt(0),
+        creator: ""
+    };
+}
+exports.Bounty = {
+    typeUrl: "/gitopia.gitopia.gitopia.Bounty",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).uint64(message.id);
+        }
+        for (const v of message.amount) {
+            coin_1.Coin.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.state !== 0) {
+            writer.uint32(24).int32(message.state);
+        }
+        if (message.repositoryId !== BigInt(0)) {
+            writer.uint32(32).uint64(message.repositoryId);
+        }
+        if (message.parentIid !== BigInt(0)) {
+            writer.uint32(40).uint64(message.parentIid);
+        }
+        if (message.parent !== 0) {
+            writer.uint32(48).int32(message.parent);
+        }
+        if (message.expireAt !== BigInt(0)) {
+            writer.uint32(56).int64(message.expireAt);
+        }
+        if (message.rewardedTo !== "") {
+            writer.uint32(66).string(message.rewardedTo);
+        }
+        if (message.createdAt !== BigInt(0)) {
+            writer.uint32(72).int64(message.createdAt);
+        }
+        if (message.updatedAt !== BigInt(0)) {
+            writer.uint32(80).int64(message.updatedAt);
+        }
+        if (message.creator !== "") {
+            writer.uint32(90).string(message.creator);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBounty();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint64();
+                    break;
+                case 2:
+                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.state = reader.int32();
+                    break;
+                case 4:
+                    message.repositoryId = reader.uint64();
+                    break;
+                case 5:
+                    message.parentIid = reader.uint64();
+                    break;
+                case 6:
+                    message.parent = reader.int32();
+                    break;
+                case 7:
+                    message.expireAt = reader.int64();
+                    break;
+                case 8:
+                    message.rewardedTo = reader.string();
+                    break;
+                case 9:
+                    message.createdAt = reader.int64();
+                    break;
+                case 10:
+                    message.updatedAt = reader.int64();
+                    break;
+                case 11:
+                    message.creator = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBounty();
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        message.amount = object.amount?.map(e => coin_1.Coin.fromPartial(e)) || [];
+        message.state = object.state ?? 0;
+        message.repositoryId = object.repositoryId !== undefined && object.repositoryId !== null ? BigInt(object.repositoryId.toString()) : BigInt(0);
+        message.parentIid = object.parentIid !== undefined && object.parentIid !== null ? BigInt(object.parentIid.toString()) : BigInt(0);
+        message.parent = object.parent ?? 0;
+        message.expireAt = object.expireAt !== undefined && object.expireAt !== null ? BigInt(object.expireAt.toString()) : BigInt(0);
+        message.rewardedTo = object.rewardedTo ?? "";
+        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
+        message.updatedAt = object.updatedAt !== undefined && object.updatedAt !== null ? BigInt(object.updatedAt.toString()) : BigInt(0);
+        message.creator = object.creator ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBounty();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        message.amount = object.amount?.map(e => coin_1.Coin.fromAmino(e)) || [];
+        if (object.state !== undefined && object.state !== null) {
+            message.state = object.state;
+        }
+        if (object.repositoryId !== undefined && object.repositoryId !== null) {
+            message.repositoryId = BigInt(object.repositoryId);
+        }
+        if (object.parentIid !== undefined && object.parentIid !== null) {
+            message.parentIid = BigInt(object.parentIid);
+        }
+        if (object.parent !== undefined && object.parent !== null) {
+            message.parent = object.parent;
+        }
+        if (object.expireAt !== undefined && object.expireAt !== null) {
+            message.expireAt = BigInt(object.expireAt);
+        }
+        if (object.rewardedTo !== undefined && object.rewardedTo !== null) {
+            message.rewardedTo = object.rewardedTo;
+        }
+        if (object.createdAt !== undefined && object.createdAt !== null) {
+            message.createdAt = BigInt(object.createdAt);
+        }
+        if (object.updatedAt !== undefined && object.updatedAt !== null) {
+            message.updatedAt = BigInt(object.updatedAt);
+        }
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        if (message.amount) {
+            obj.amount = message.amount.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.amount = message.amount;
+        }
+        obj.state = message.state === 0 ? undefined : message.state;
+        obj.repositoryId = message.repositoryId !== BigInt(0) ? message.repositoryId?.toString() : undefined;
+        obj.parentIid = message.parentIid !== BigInt(0) ? message.parentIid?.toString() : undefined;
+        obj.parent = message.parent === 0 ? undefined : message.parent;
+        obj.expireAt = message.expireAt !== BigInt(0) ? message.expireAt?.toString() : undefined;
+        obj.rewardedTo = message.rewardedTo === "" ? undefined : message.rewardedTo;
+        obj.createdAt = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
+        obj.updatedAt = message.updatedAt !== BigInt(0) ? message.updatedAt?.toString() : undefined;
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Bounty.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Bounty.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Bounty.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.Bounty",
+            value: exports.Bounty.encode(message).finish()
+        };
+    }
+};