@sparkdreamnft/sparkdreamjs 0.0.8 → 0.0.10

package/sparkdream/federation/v1/genesis.d.ts

@@ -0,0 +1,79 @@
+import { Params, ParamsAmino } from "./params";
+import { Peer, PeerAmino, PeerPolicy, PeerPolicyAmino, BridgeOperator, BridgeOperatorAmino, FederatedContent, FederatedContentAmino, IdentityLink, IdentityLinkAmino, ReputationAttestation, ReputationAttestationAmino, OutboundAttestation, OutboundAttestationAmino, VerificationRecord, VerificationRecordAmino } from "./types";
+import { VerifierActivity, VerifierActivityAmino } from "./verifier_activity";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * GenesisState defines the federation module's genesis state.
+ * @name GenesisState
+ * @package sparkdream.federation.v1
+ * @see proto type: sparkdream.federation.v1.GenesisState
+ */
+export interface GenesisState {
+    /**
+     * params defines all the parameters of the module.
+     */
+    params: Params;
+    portId: string;
+    peers: Peer[];
+    peerPolicies: PeerPolicy[];
+    bridgeOperators: BridgeOperator[];
+    federatedContent: FederatedContent[];
+    identityLinks: IdentityLink[];
+    reputationAttestations: ReputationAttestation[];
+    outboundAttestations: OutboundAttestation[];
+    verifierActivities: VerifierActivity[];
+    verificationRecords: VerificationRecord[];
+    nextContentId: bigint;
+    nextOutboundAttestationId: bigint;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/sparkdream.federation.v1.GenesisState";
+    value: Uint8Array;
+}
+/**
+ * GenesisState defines the federation module's genesis state.
+ * @name GenesisStateAmino
+ * @package sparkdream.federation.v1
+ * @see proto type: sparkdream.federation.v1.GenesisState
+ */
+export interface GenesisStateAmino {
+    /**
+     * params defines all the parameters of the module.
+     */
+    params: ParamsAmino;
+    port_id?: string;
+    peers?: PeerAmino[];
+    peer_policies?: PeerPolicyAmino[];
+    bridge_operators?: BridgeOperatorAmino[];
+    federated_content?: FederatedContentAmino[];
+    identity_links?: IdentityLinkAmino[];
+    reputation_attestations?: ReputationAttestationAmino[];
+    outbound_attestations?: OutboundAttestationAmino[];
+    verifier_activities?: VerifierActivityAmino[];
+    verification_records?: VerificationRecordAmino[];
+    next_content_id?: string;
+    next_outbound_attestation_id?: string;
+}
+export interface GenesisStateAminoMsg {
+    type: "/sparkdream.federation.v1.GenesisState";
+    value: GenesisStateAmino;
+}
+/**
+ * GenesisState defines the federation module's genesis state.
+ * @name GenesisState
+ * @package sparkdream.federation.v1
+ * @see proto type: sparkdream.federation.v1.GenesisState
+ */
+export declare const GenesisState: {
+    typeUrl: string;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

package/sparkdream/federation/v1/genesis.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+//@ts-nocheck
+const params_1 = require("./params");
+const types_1 = require("./types");
+const verifier_activity_1 = require("./verifier_activity");
+const binary_1 = require("../../../binary");
+function createBaseGenesisState() {
+    return {
+        params: params_1.Params.fromPartial({}),
+        portId: "",
+        peers: [],
+        peerPolicies: [],
+        bridgeOperators: [],
+        federatedContent: [],
+        identityLinks: [],
+        reputationAttestations: [],
+        outboundAttestations: [],
+        verifierActivities: [],
+        verificationRecords: [],
+        nextContentId: BigInt(0),
+        nextOutboundAttestationId: BigInt(0)
+    };
+}
+/**
+ * GenesisState defines the federation module's genesis state.
+ * @name GenesisState
+ * @package sparkdream.federation.v1
+ * @see proto type: sparkdream.federation.v1.GenesisState
+ */
+exports.GenesisState = {
+    typeUrl: "/sparkdream.federation.v1.GenesisState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.portId !== "") {
+            writer.uint32(18).string(message.portId);
+        }
+        for (const v of message.peers) {
+            types_1.Peer.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.peerPolicies) {
+            types_1.PeerPolicy.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.bridgeOperators) {
+            types_1.BridgeOperator.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.federatedContent) {
+            types_1.FederatedContent.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.identityLinks) {
+            types_1.IdentityLink.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        for (const v of message.reputationAttestations) {
+            types_1.ReputationAttestation.encode(v, writer.uint32(66).fork()).ldelim();
+        }
+        for (const v of message.outboundAttestations) {
+            types_1.OutboundAttestation.encode(v, writer.uint32(74).fork()).ldelim();
+        }
+        for (const v of message.verifierActivities) {
+            verifier_activity_1.VerifierActivity.encode(v, writer.uint32(114).fork()).ldelim();
+        }
+        for (const v of message.verificationRecords) {
+            types_1.VerificationRecord.encode(v, writer.uint32(90).fork()).ldelim();
+        }
+        if (message.nextContentId !== BigInt(0)) {
+            writer.uint32(96).uint64(message.nextContentId);
+        }
+        if (message.nextOutboundAttestationId !== BigInt(0)) {
+            writer.uint32(104).uint64(message.nextOutboundAttestationId);
+        }
+        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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = params_1.Params.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.portId = reader.string();
+                    break;
+                case 3:
+                    message.peers.push(types_1.Peer.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.peerPolicies.push(types_1.PeerPolicy.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.bridgeOperators.push(types_1.BridgeOperator.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.federatedContent.push(types_1.FederatedContent.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.identityLinks.push(types_1.IdentityLink.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.reputationAttestations.push(types_1.ReputationAttestation.decode(reader, reader.uint32()));
+                    break;
+                case 9:
+                    message.outboundAttestations.push(types_1.OutboundAttestation.decode(reader, reader.uint32()));
+                    break;
+                case 14:
+                    message.verifierActivities.push(verifier_activity_1.VerifierActivity.decode(reader, reader.uint32()));
+                    break;
+                case 11:
+                    message.verificationRecords.push(types_1.VerificationRecord.decode(reader, reader.uint32()));
+                    break;
+                case 12:
+                    message.nextContentId = reader.uint64();
+                    break;
+                case 13:
+                    message.nextOutboundAttestationId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.params = object.params !== undefined && object.params !== null ? params_1.Params.fromPartial(object.params) : undefined;
+        message.portId = object.portId ?? "";
+        message.peers = object.peers?.map(e => types_1.Peer.fromPartial(e)) || [];
+        message.peerPolicies = object.peerPolicies?.map(e => types_1.PeerPolicy.fromPartial(e)) || [];
+        message.bridgeOperators = object.bridgeOperators?.map(e => types_1.BridgeOperator.fromPartial(e)) || [];
+        message.federatedContent = object.federatedContent?.map(e => types_1.FederatedContent.fromPartial(e)) || [];
+        message.identityLinks = object.identityLinks?.map(e => types_1.IdentityLink.fromPartial(e)) || [];
+        message.reputationAttestations = object.reputationAttestations?.map(e => types_1.ReputationAttestation.fromPartial(e)) || [];
+        message.outboundAttestations = object.outboundAttestations?.map(e => types_1.OutboundAttestation.fromPartial(e)) || [];
+        message.verifierActivities = object.verifierActivities?.map(e => verifier_activity_1.VerifierActivity.fromPartial(e)) || [];
+        message.verificationRecords = object.verificationRecords?.map(e => types_1.VerificationRecord.fromPartial(e)) || [];
+        message.nextContentId = object.nextContentId !== undefined && object.nextContentId !== null ? BigInt(object.nextContentId.toString()) : BigInt(0);
+        message.nextOutboundAttestationId = object.nextOutboundAttestationId !== undefined && object.nextOutboundAttestationId !== null ? BigInt(object.nextOutboundAttestationId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = params_1.Params.fromAmino(object.params);
+        }
+        if (object.port_id !== undefined && object.port_id !== null) {
+            message.portId = object.port_id;
+        }
+        message.peers = object.peers?.map(e => types_1.Peer.fromAmino(e)) || [];
+        message.peerPolicies = object.peer_policies?.map(e => types_1.PeerPolicy.fromAmino(e)) || [];
+        message.bridgeOperators = object.bridge_operators?.map(e => types_1.BridgeOperator.fromAmino(e)) || [];
+        message.federatedContent = object.federated_content?.map(e => types_1.FederatedContent.fromAmino(e)) || [];
+        message.identityLinks = object.identity_links?.map(e => types_1.IdentityLink.fromAmino(e)) || [];
+        message.reputationAttestations = object.reputation_attestations?.map(e => types_1.ReputationAttestation.fromAmino(e)) || [];
+        message.outboundAttestations = object.outbound_attestations?.map(e => types_1.OutboundAttestation.fromAmino(e)) || [];
+        message.verifierActivities = object.verifier_activities?.map(e => verifier_activity_1.VerifierActivity.fromAmino(e)) || [];
+        message.verificationRecords = object.verification_records?.map(e => types_1.VerificationRecord.fromAmino(e)) || [];
+        if (object.next_content_id !== undefined && object.next_content_id !== null) {
+            message.nextContentId = BigInt(object.next_content_id);
+        }
+        if (object.next_outbound_attestation_id !== undefined && object.next_outbound_attestation_id !== null) {
+            message.nextOutboundAttestationId = BigInt(object.next_outbound_attestation_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? params_1.Params.toAmino(message.params) : params_1.Params.toAmino(params_1.Params.fromPartial({}));
+        obj.port_id = message.portId === "" ? undefined : message.portId;
+        if (message.peers) {
+            obj.peers = message.peers.map(e => e ? types_1.Peer.toAmino(e) : undefined);
+        }
+        else {
+            obj.peers = message.peers;
+        }
+        if (message.peerPolicies) {
+            obj.peer_policies = message.peerPolicies.map(e => e ? types_1.PeerPolicy.toAmino(e) : undefined);
+        }
+        else {
+            obj.peer_policies = message.peerPolicies;
+        }
+        if (message.bridgeOperators) {
+            obj.bridge_operators = message.bridgeOperators.map(e => e ? types_1.BridgeOperator.toAmino(e) : undefined);
+        }
+        else {
+            obj.bridge_operators = message.bridgeOperators;
+        }
+        if (message.federatedContent) {
+            obj.federated_content = message.federatedContent.map(e => e ? types_1.FederatedContent.toAmino(e) : undefined);
+        }
+        else {
+            obj.federated_content = message.federatedContent;
+        }
+        if (message.identityLinks) {
+            obj.identity_links = message.identityLinks.map(e => e ? types_1.IdentityLink.toAmino(e) : undefined);
+        }
+        else {
+            obj.identity_links = message.identityLinks;
+        }
+        if (message.reputationAttestations) {
+            obj.reputation_attestations = message.reputationAttestations.map(e => e ? types_1.ReputationAttestation.toAmino(e) : undefined);
+        }
+        else {
+            obj.reputation_attestations = message.reputationAttestations;
+        }
+        if (message.outboundAttestations) {
+            obj.outbound_attestations = message.outboundAttestations.map(e => e ? types_1.OutboundAttestation.toAmino(e) : undefined);
+        }
+        else {
+            obj.outbound_attestations = message.outboundAttestations;
+        }
+        if (message.verifierActivities) {
+            obj.verifier_activities = message.verifierActivities.map(e => e ? verifier_activity_1.VerifierActivity.toAmino(e) : undefined);
+        }
+        else {
+            obj.verifier_activities = message.verifierActivities;
+        }
+        if (message.verificationRecords) {
+            obj.verification_records = message.verificationRecords.map(e => e ? types_1.VerificationRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.verification_records = message.verificationRecords;
+        }
+        obj.next_content_id = message.nextContentId !== BigInt(0) ? message.nextContentId?.toString() : undefined;
+        obj.next_outbound_attestation_id = message.nextOutboundAttestationId !== BigInt(0) ? message.nextOutboundAttestationId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.federation.v1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};