@show-karma/karma-gap-sdk 0.1.29

package/core/class/contract/GapContract.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapContract = void 0;
+const GAP_1 = require("../GAP");
+const serialize_bigint_1 = require("../../utils/serialize-bigint");
+const send_gelato_txn_1 = require("../../utils/gelato/send-gelato-txn");
+const eas_sdk_1 = require("@ethereum-attestation-service/eas-sdk");
+const AttestationDataTypes = {
+    Attest: [
+        { name: 'payloadHash', type: 'string' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'expiry', type: 'uint256' },
+    ],
+};
+class GapContract {
+    /**
+     * Signs a message for the delegated attestation.
+     * @param signer
+     * @param payload
+     * @returns r,s,v signature
+     */
+    static async signAttestation(signer, payload, expiry) {
+        let { nonce } = await this.getNonce(signer);
+        const { chainId } = await signer.provider.getNetwork();
+        const domain = {
+            chainId,
+            name: 'gap-attestation',
+            version: '1',
+            verifyingContract: GAP_1.GAP.getMulticall(null).address,
+        };
+        const data = { payloadHash: payload, nonce, expiry };
+        console.log({ domain, AttestationDataTypes, data });
+        const signature = await signer._signTypedData(domain, AttestationDataTypes, data);
+        const { r, s, v } = this.getRSV(signature);
+        return { r, s, v, nonce, chainId };
+    }
+    /**
+     * Returns the r, s, v values of a signature
+     * @param signature
+     * @returns
+     */
+    static getRSV(signature) {
+        const r = signature.slice(0, 66);
+        const s = `0x${signature.slice(66, 130)}`;
+        const v = `0x${signature.slice(130, 132)}`;
+        return { r, s, v };
+    }
+    static async getSignerAddress(signer) {
+        const address = signer.address || signer._address || (await signer.getAddress());
+        if (!address)
+            throw new Error('Signer does not provider either address or getAddress().');
+        return address;
+    }
+    /**
+     * Get nonce for the transaction
+     * @param address
+     * @returns
+     */
+    static async getNonce(signer) {
+        const contract = GAP_1.GAP.getMulticall(signer);
+        const address = await this.getSignerAddress(signer);
+        console.log({ address });
+        const nonce = await contract.functions.nonces(address);
+        return {
+            nonce: Number(nonce),
+            next: Number(nonce + 1n),
+        };
+    }
+    /**
+     * Send a single attestation
+     * @param signer
+     * @param payload
+     * @returns
+     */
+    static async attest(signer, payload) {
+        const contract = GAP_1.GAP.getMulticall(signer);
+        if (GAP_1.GAP.gelatoOpts?.useGasless) {
+            return this.attestBySig(signer, payload);
+        }
+        const tx = await contract.functions.attest({
+            schema: payload.schema,
+            data: payload.data.payload,
+        });
+        const result = await tx.wait?.();
+        const attestations = (0, eas_sdk_1.getUIDsFromAttestReceipt)(result)[0];
+        return attestations;
+    }
+    static async attestBySig(signer, payload) {
+        const contract = GAP_1.GAP.getMulticall(signer);
+        const expiry = BigInt(Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 30);
+        const address = await this.getSignerAddress(signer);
+        const payloadHash = (0, serialize_bigint_1.serializeWithBigint)({
+            schema: payload.schema,
+            data: payload.data.raw,
+        });
+        const { r, s, v, nonce, chainId } = await this.signAttestation(signer, payloadHash, expiry);
+        const { data: populatedTxn } = await contract.populateTransaction.attestBySig({
+            data: payload.data.payload,
+            schema: payload.schema,
+        }, payloadHash, address, nonce, expiry, v, r, s);
+        if (!populatedTxn)
+            throw new Error('Transaction data is empty');
+        const txn = await (0, send_gelato_txn_1.sendGelatoTxn)(...send_gelato_txn_1.Gelato.buildArgs(populatedTxn, chainId, contract.address));
+        const attestations = await this.getTransactionLogs(signer, txn);
+        return attestations[0];
+    }
+    /**
+     * Performs a referenced multi attestation.
+     *
+     * @returns an array with the attestation UIDs.
+     */
+    static async multiAttest(signer, payload) {
+        const contract = GAP_1.GAP.getMulticall(signer);
+        if (GAP_1.GAP.gelatoOpts?.useGasless) {
+            return this.multiAttestBySig(signer, payload);
+        }
+        const tx = await contract.functions.multiSequentialAttest(payload.map((p) => p.payload));
+        const result = await tx.wait?.();
+        const attestations = (0, eas_sdk_1.getUIDsFromAttestReceipt)(result);
+        return attestations;
+    }
+    /**
+     * Performs a referenced multi attestation.
+     *
+     * @returns an array with the attestation UIDs.
+     */
+    static async multiAttestBySig(signer, payload) {
+        const contract = GAP_1.GAP.getMulticall(signer);
+        const expiry = BigInt(Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 30);
+        const address = await this.getSignerAddress(signer);
+        const payloadHash = (0, serialize_bigint_1.serializeWithBigint)(payload.map((p) => p.raw));
+        const { r, s, v, nonce, chainId } = await this.signAttestation(signer, payloadHash, expiry);
+        console.info({ r, s, v, nonce, chainId, payloadHash, address });
+        const { data: populatedTxn } = await contract.populateTransaction.multiSequentialAttestBySig(payload.map((p) => p.payload), payloadHash, address, nonce, expiry, v, r, s);
+        if (!populatedTxn)
+            throw new Error('Transaction data is empty');
+        const txn = await (0, send_gelato_txn_1.sendGelatoTxn)(...send_gelato_txn_1.Gelato.buildArgs(populatedTxn, chainId, contract.address));
+        const attestations = await this.getTransactionLogs(signer, txn);
+        return attestations;
+    }
+    static async multiRevoke(signer, payload) {
+        const contract = GAP_1.GAP.getMulticall(signer);
+        if (GAP_1.GAP.gelatoOpts?.useGasless) {
+            return this.multiRevokeBySig(signer, payload);
+        }
+        const tx = await contract.functions.multiRevoke(payload);
+        return tx.wait?.();
+    }
+    /**
+     * Performs a referenced multi attestation.
+     *
+     * @returns an array with the attestation UIDs.
+     */
+    static async multiRevokeBySig(signer, payload) {
+        const contract = GAP_1.GAP.getMulticall(signer);
+        const expiry = BigInt(Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 30);
+        const address = await this.getSignerAddress(signer);
+        const payloadHash = (0, serialize_bigint_1.serializeWithBigint)(payload);
+        const { r, s, v, nonce, chainId } = await this.signAttestation(signer, payloadHash, expiry);
+        console.info({ r, s, v, nonce, chainId, payloadHash, address });
+        const { data: populatedTxn } = await contract.populateTransaction.multiRevokeBySig(payload, payloadHash, address, nonce, expiry, v, r, s);
+        if (!populatedTxn)
+            throw new Error('Transaction data is empty');
+        await (0, send_gelato_txn_1.sendGelatoTxn)(...send_gelato_txn_1.Gelato.buildArgs(populatedTxn, chainId, contract.address));
+    }
+    static async getTransactionLogs(signer, txnHash) {
+        const txn = await signer.provider.getTransactionReceipt(txnHash);
+        if (!txn || !txn.logs.length)
+            throw new Error('Transaction not found');
+        // Returns the txn logs with the attestation results. Tha last two logs are the
+        // the ones from the GelatoRelay contract.
+        return (0, eas_sdk_1.getUIDsFromAttestReceipt)(txn);
+    }
+}
+exports.GapContract = GapContract;
+GapContract.nonces = {};

package/core/class/contract/MultiAttest.d.ts

@@ -0,0 +1,10 @@
+import { SignerOrProvider } from "@ethereum-attestation-service/eas-sdk/dist/transaction";
+import { Hex, MultiAttestData } from "core/types";
+export declare class MultiAttest {
+    /**
+     * Performs a referenced multi attestation.
+     *
+     * @returns an array with the attestation UIDs.
+     */
+    static send(signer: SignerOrProvider, payload: MultiAttestData[]): Promise<Hex[]>;
+}

package/core/class/contract/MultiAttest.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiAttest = void 0;
+const GAP_1 = require("../GAP");
+class MultiAttest {
+    /**
+     * Performs a referenced multi attestation.
+     *
+     * @returns an array with the attestation UIDs.
+     */
+    static async send(signer, payload) {
+        const contract = GAP_1.GAP.getMulticall(signer);
+        const tx = await contract.functions.multiSequentialAttest(payload);
+        const result = await tx.wait?.();
+        const attestations = result.logs?.map((m) => m.data);
+        return attestations;
+    }
+}
+exports.MultiAttest = MultiAttest;

package/core/class/entities/Community.d.ts

@@ -0,0 +1,36 @@
+import { Attestation } from "../Attestation";
+import { CommunityDetails, ICommunityDetails } from "../types/attestations";
+import { Project } from "./Project";
+import { MultiAttestPayload, SignerOrProvider } from "core/types";
+import { Grant } from "./Grant";
+interface _Community extends Community {
+}
+export interface ICommunity {
+    community: true;
+}
+export declare class Community extends Attestation<ICommunity> {
+    projects: Project[];
+    grants: Grant[];
+    details?: CommunityDetails;
+    /**
+     * Creates the payload for a multi-attestation.
+     *
+     * > if Current payload is set, it'll be used as the base payload
+     * and the project should refer to an index of the current payload,
+     * usually the community position.
+     *
+     * @param payload
+     * @param refIdx
+     */
+    multiAttestPayload(): MultiAttestPayload;
+    /**
+     * Attest a community with its details.
+     *
+     * If the community exists, it will not be revoked but its details will be updated.
+     * @param signer
+     * @param details
+     */
+    attest(signer: SignerOrProvider, details?: ICommunityDetails): Promise<void>;
+    static from(attestations: _Community[]): Community[];
+}
+export {};

package/core/class/entities/Community.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Community = void 0;
+const Attestation_1 = require("../Attestation");
+const attestations_1 = require("../types/attestations");
+const consts_1 = require("../../consts");
+const SchemaError_1 = require("../SchemaError");
+const GapSchema_1 = require("../GapSchema");
+const Grant_1 = require("./Grant");
+class Community extends Attestation_1.Attestation {
+    constructor() {
+        super(...arguments);
+        this.projects = [];
+        this.grants = [];
+    }
+    /**
+     * Creates the payload for a multi-attestation.
+     *
+     * > if Current payload is set, it'll be used as the base payload
+     * and the project should refer to an index of the current payload,
+     * usually the community position.
+     *
+     * @param payload
+     * @param refIdx
+     */
+    multiAttestPayload() {
+        const payload = [[this, this.payloadFor(0)]];
+        if (this.details) {
+            payload.push([this.details, this.details.payloadFor(0)]);
+        }
+        if (this.projects?.length) {
+            this.projects.forEach((p) => {
+                payload.push(...p.multiAttestPayload(payload, 0));
+            });
+        }
+        return payload;
+    }
+    /**
+     * Attest a community with its details.
+     *
+     * If the community exists, it will not be revoked but its details will be updated.
+     * @param signer
+     * @param details
+     */
+    async attest(signer, details) {
+        console.log("Attesting community");
+        try {
+            this._uid = await this.schema.attest({
+                signer,
+                to: this.recipient,
+                refUID: consts_1.nullRef,
+                data: this.data,
+            });
+            console.log(this.uid);
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Error during attestation.");
+        }
+    }
+    static from(attestations) {
+        return attestations.map((attestation) => {
+            const community = new Community({
+                ...attestation,
+                data: {
+                    community: true,
+                },
+                schema: GapSchema_1.GapSchema.find("Community"),
+            });
+            if (attestation.details) {
+                const { details } = attestation;
+                community.details = new attestations_1.CommunityDetails({
+                    ...details,
+                    data: {
+                        ...details.data,
+                    },
+                    schema: GapSchema_1.GapSchema.find("CommunityDetails"),
+                });
+            }
+            if (attestation.grants) {
+                const { grants } = attestation;
+                community.grants = Grant_1.Grant.from(grants);
+            }
+            return community;
+        });
+    }
+}
+exports.Community = Community;

package/core/class/entities/Grant.d.ts

@@ -0,0 +1,53 @@
+import { Attestation } from '../Attestation';
+import { GrantDetails, GrantRound, GrantUpdate, IGrantUpdate, GrantCompleted } from '../types/attestations';
+import { IMilestone, Milestone } from './Milestone';
+import { GapSchema } from '../GapSchema';
+import { Hex, MultiAttestPayload, SignerOrProvider } from 'core/types';
+import { Community } from './Community';
+import { Project } from './Project';
+interface _Grant extends Grant {
+}
+export interface IGrant {
+    communityUID: Hex;
+}
+export declare class Grant extends Attestation<IGrant> {
+    details?: GrantDetails;
+    communityUID: Hex;
+    verified?: boolean;
+    round?: GrantRound;
+    milestones: Milestone[];
+    community: Community;
+    updates: GrantUpdate[];
+    completed?: GrantCompleted;
+    project?: Project;
+    verify(signer: SignerOrProvider): Promise<void>;
+    /**
+     * Add milestones to the grant.
+     * @param signer
+     * @param milestones
+     */
+    addMilestones(milestones: IMilestone[]): void;
+    /**
+     * Creates the payload for a multi-attestation.
+     *
+     * > if Current payload is set, it'll be used as the base payload
+     * and the project should refer to an index of the current payload,
+     * usually the community position.
+     *
+     * @param payload
+     * @param projectIdx
+     */
+    multiAttestPayload(currentPayload?: MultiAttestPayload, projectIdx?: number): [Attestation<unknown, GapSchema>, import("core/types").RawMultiAttestPayload][];
+    /**
+     * @inheritdoc
+     */
+    attest(signer: SignerOrProvider): Promise<void>;
+    attestUpdate(signer: SignerOrProvider, data: IGrantUpdate): Promise<void>;
+    complete(signer: SignerOrProvider, data: IGrantUpdate): Promise<void>;
+    /**
+     * Validate if the grant has a valid reference to a community.
+     */
+    protected assertPayload(): boolean;
+    static from(attestations: _Grant[]): Grant[];
+}
+export {};

package/core/class/entities/Grant.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Grant = void 0;
+const Attestation_1 = require("../Attestation");
+const attestations_1 = require("../types/attestations");
+const Milestone_1 = require("./Milestone");
+const GapSchema_1 = require("../GapSchema");
+const GAP_1 = require("../GAP");
+const SchemaError_1 = require("../SchemaError");
+const consts_1 = require("../../consts");
+const GapContract_1 = require("../contract/GapContract");
+const Community_1 = require("./Community");
+const Project_1 = require("./Project");
+class Grant extends Attestation_1.Attestation {
+    constructor() {
+        super(...arguments);
+        this.verified = false;
+        this.milestones = [];
+        this.updates = [];
+    }
+    async verify(signer) {
+        const eas = GAP_1.GAP.eas.connect(signer);
+        const schema = GapSchema_1.GapSchema.find('MilestoneApproved');
+        schema.setValue('approved', true);
+        try {
+            await eas.attest({
+                schema: schema.raw,
+                data: {
+                    recipient: this.recipient,
+                    data: schema.encode(),
+                    refUID: this.uid,
+                    expirationTime: 0n,
+                    revocable: schema.revocable,
+                },
+            });
+            this.verified = true;
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.AttestationError('ATTEST_ERROR', error.message);
+        }
+    }
+    /**
+     * Add milestones to the grant.
+     * @param signer
+     * @param milestones
+     */
+    addMilestones(milestones) {
+        const schema = GapSchema_1.GapSchema.find('Milestone');
+        const newMilestones = milestones.map((milestone) => {
+            const m = new Milestone_1.Milestone({
+                data: milestone,
+                refUID: this.uid,
+                schema,
+                createdAt: Date.now(),
+                recipient: this.recipient,
+                uid: consts_1.nullRef,
+            });
+            return m;
+        });
+        this.milestones.push(...newMilestones);
+    }
+    /**
+     * Creates the payload for a multi-attestation.
+     *
+     * > if Current payload is set, it'll be used as the base payload
+     * and the project should refer to an index of the current payload,
+     * usually the community position.
+     *
+     * @param payload
+     * @param projectIdx
+     */
+    multiAttestPayload(currentPayload = [], projectIdx = 0) {
+        this.assertPayload();
+        const payload = [...currentPayload];
+        const grantIdx = payload.push([this, this.payloadFor(projectIdx)]) - 1;
+        if (this.details) {
+            payload.push([this.details, this.details.payloadFor(grantIdx)]);
+        }
+        if (this.milestones.length) {
+            this.milestones.forEach((m) => {
+                payload.push([m, m.payloadFor(grantIdx)]);
+            });
+        }
+        if (this.updates.length) {
+            this.updates.forEach((u) => {
+                payload.push([u, u.payloadFor(grantIdx)]);
+            });
+        }
+        return payload.slice(currentPayload.length, payload.length);
+    }
+    /**
+     * @inheritdoc
+     */
+    async attest(signer) {
+        this.assertPayload();
+        const payload = this.multiAttestPayload();
+        const uids = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]));
+        uids.forEach((uid, index) => {
+            payload[index][0].uid = uid;
+        });
+        console.log(uids);
+    }
+    async attestUpdate(signer, data) {
+        const grantUpdate = new attestations_1.GrantUpdate({
+            data: {
+                ...data,
+                type: 'grant-update',
+            },
+            recipient: this.recipient,
+            refUID: this.uid,
+            schema: GapSchema_1.GapSchema.find('GrantDetails'),
+        });
+        await grantUpdate.attest(signer);
+        this.updates.push(grantUpdate);
+    }
+    async complete(signer, data) {
+        const completed = new attestations_1.GrantCompleted({
+            data: {
+                ...data,
+                type: 'grant-completed',
+            },
+            recipient: this.recipient,
+            refUID: this.uid,
+            schema: GapSchema_1.GapSchema.find('GrantDetails'),
+        });
+        await completed.attest(signer);
+        this.completed = completed;
+    }
+    /**
+     * Validate if the grant has a valid reference to a community.
+     */
+    assertPayload() {
+        if (!this.details || !this.communityUID) {
+            throw new SchemaError_1.AttestationError('INVALID_REFERENCE', 'Grant should include a valid reference to a community on its details.');
+        }
+        return true;
+    }
+    static from(attestations) {
+        return attestations.map((attestation) => {
+            const grant = new Grant({
+                ...attestation,
+                data: {
+                    communityUID: attestation.data.communityUID,
+                },
+                schema: GapSchema_1.GapSchema.find('Grant'),
+            });
+            if (attestation.details) {
+                const { details } = attestation;
+                grant.details = new attestations_1.GrantDetails({
+                    ...details,
+                    data: {
+                        ...details.data,
+                    },
+                    schema: GapSchema_1.GapSchema.find('GrantDetails'),
+                });
+            }
+            if (attestation.milestones) {
+                const { milestones } = attestation;
+                grant.milestones = Milestone_1.Milestone.from(milestones);
+            }
+            if (attestation.updates) {
+                const { updates } = attestation;
+                grant.updates = updates.map((u) => new attestations_1.GrantUpdate({
+                    ...u,
+                    data: {
+                        ...u.data,
+                    },
+                    schema: GapSchema_1.GapSchema.find('GrantDetails'),
+                }));
+            }
+            if (attestation.completed) {
+                const { completed } = attestation;
+                grant.completed = new attestations_1.GrantCompleted({
+                    ...completed,
+                    data: {
+                        ...completed.data,
+                    },
+                    schema: GapSchema_1.GapSchema.find('GrantDetails'),
+                });
+            }
+            if (attestation.project) {
+                const { project } = attestation;
+                grant.project = Project_1.Project.from([project])[0];
+            }
+            if (attestation.community) {
+                const { community } = attestation;
+                grant.community = Community_1.Community.from([community])[0];
+            }
+            return grant;
+        });
+    }
+}
+exports.Grant = Grant;

package/core/class/entities/MemberOf.d.ts

@@ -0,0 +1,11 @@
+import { MultiAttestPayload, SignerOrProvider } from "core/types";
+import { Attestation } from "../Attestation";
+import { MemberDetails } from "../types/attestations";
+export interface IMemberOf {
+    memberOf: true;
+}
+export declare class MemberOf extends Attestation<IMemberOf> {
+    details?: MemberDetails;
+    multiAttestPayload(currentPayload?: MultiAttestPayload, projectIdx?: number): [Attestation<unknown, import("..").GapSchema>, import("core/types").RawMultiAttestPayload][];
+    attest(signer: SignerOrProvider): Promise<void>;
+}

package/core/class/entities/MemberOf.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberOf = void 0;
+const Attestation_1 = require("../Attestation");
+const SchemaError_1 = require("../SchemaError");
+const GapContract_1 = require("../contract/GapContract");
+class MemberOf extends Attestation_1.Attestation {
+    multiAttestPayload(currentPayload = [], projectIdx = 0) {
+        const payload = [...currentPayload];
+        const memberIdx = payload.push([this, this.payloadFor(projectIdx)]) - 1;
+        if (this.details) {
+            payload.push([this.details, this.details.payloadFor(memberIdx)]);
+        }
+        return payload.slice(currentPayload.length, payload.length);
+    }
+    async attest(signer) {
+        const payload = this.multiAttestPayload();
+        try {
+            const [memberUID, detailsUID] = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]));
+            this.uid = memberUID;
+            if (this.details && detailsUID) {
+                this.details.uid = detailsUID;
+            }
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", error.message);
+        }
+    }
+}
+exports.MemberOf = MemberOf;

package/core/class/entities/Milestone.d.ts

@@ -0,0 +1,63 @@
+import { SignerOrProvider } from "../../types";
+import { Attestation } from "../Attestation";
+import { MilestoneCompleted } from "../types/attestations";
+interface _Milestone extends Milestone {
+}
+export interface IMilestone {
+    title: string;
+    endsAt: number;
+    description: string;
+}
+export declare class Milestone extends Attestation<IMilestone> implements IMilestone {
+    title: string;
+    endsAt: number;
+    description: string;
+    completed: MilestoneCompleted;
+    approved: MilestoneCompleted;
+    rejected: MilestoneCompleted;
+    /**
+     * Approves this milestone. If the milestone is not completed or already approved,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    approve(signer: SignerOrProvider, reason?: string): Promise<void>;
+    /**
+     * Revokes the approved status of the milestone. If the milestone is not approved,
+     * it will throw an error.
+     * @param signer
+     */
+    revokeApproval(signer: SignerOrProvider): Promise<void>;
+    /**
+     * Reject a completed milestone. If the milestone is not completed or already rejected,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    reject(signer: SignerOrProvider, reason?: string): Promise<void>;
+    /**
+     * Revokes the rejected status of the milestone. If the milestone is not rejected,
+     * it will throw an error.
+     * @param signer
+     */
+    revokeRejection(signer: SignerOrProvider): Promise<void>;
+    /**
+     * Marks a milestone as completed. If the milestone is already completed,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    complete(signer: SignerOrProvider, reason?: string): Promise<void>;
+    /**
+     * Revokes the completed status of the milestone. If the milestone is not completed,
+     * it will throw an error.
+     * @param signer
+     */
+    revokeCompletion(signer: SignerOrProvider): Promise<void>;
+    /**
+     * Attest the status of the milestone as approved, rejected or completed.
+     */
+    private attestStatus;
+    static from(attestations: _Milestone[]): Milestone[];
+}
+export {};