@totemsdk/provider-bond 0.1.0

package/dist/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProvidersByServiceType = exports.getProvider = exports.listProviders = exports.updateProviderScore = exports.recordProviderIncident = exports.recordProviderProbe = exports.attachBondProof = exports.updateProviderManifest = exports.registerProvider = exports.createEmptyProviderBondRegistryState = exports.explainProviderPolicyMatch = exports.rankProvidersByPolicy = exports.filterProvidersByPolicy = exports.computeProviderRecommendation = exports.computeProviderScore = exports.rejectIncident = exports.resolveIncident = exports.acknowledgeIncident = exports.recordIncident = exports.recordHeartbeat = exports.recordProbe = exports.verifyBondStack = exports.assertBondMeetsMinimum = exports.verifyBondProof = exports.assertProviderControlsAddress = exports.verifyProviderBondAddresses = exports.verifyProviderManifestIdentity = exports.bindProviderManifestToIdentity = exports.assertManifestNotExpired = exports.verifyProviderBondManifest = exports.computeProviderBondManifestHash = exports.computeProviderBondExtensionHash = exports.createProviderBondManifest = exports.parseProviderBondRecord = exports.serializeProviderBondRecord = exports.parseProviderBondState = exports.serializeProviderBondState = exports.DEFAULT_PROVIDER_SCORING_WEIGHTS = exports.PROVIDER_BOND_TOPIC_PREFIX = exports.DEFAULT_MINIMA_TOKEN_ID = exports.ProviderSerializationError = exports.ProviderRegistryError = exports.ProviderPolicyError = exports.ProviderScoreError = exports.IncidentError = exports.ProbeError = exports.BondProofError = exports.ProviderIdentityError = exports.ProviderManifestError = exports.ProviderBondError = void 0;
+exports.MemoryProviderBondStore = exports.listOfflineProviders = exports.listRiskyProviders = void 0;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "ProviderBondError", { enumerable: true, get: function () { return errors_js_1.ProviderBondError; } });
+Object.defineProperty(exports, "ProviderManifestError", { enumerable: true, get: function () { return errors_js_1.ProviderManifestError; } });
+Object.defineProperty(exports, "ProviderIdentityError", { enumerable: true, get: function () { return errors_js_1.ProviderIdentityError; } });
+Object.defineProperty(exports, "BondProofError", { enumerable: true, get: function () { return errors_js_1.BondProofError; } });
+Object.defineProperty(exports, "ProbeError", { enumerable: true, get: function () { return errors_js_1.ProbeError; } });
+Object.defineProperty(exports, "IncidentError", { enumerable: true, get: function () { return errors_js_1.IncidentError; } });
+Object.defineProperty(exports, "ProviderScoreError", { enumerable: true, get: function () { return errors_js_1.ProviderScoreError; } });
+Object.defineProperty(exports, "ProviderPolicyError", { enumerable: true, get: function () { return errors_js_1.ProviderPolicyError; } });
+Object.defineProperty(exports, "ProviderRegistryError", { enumerable: true, get: function () { return errors_js_1.ProviderRegistryError; } });
+Object.defineProperty(exports, "ProviderSerializationError", { enumerable: true, get: function () { return errors_js_1.ProviderSerializationError; } });
+var constants_js_1 = require("./constants.js");
+Object.defineProperty(exports, "DEFAULT_MINIMA_TOKEN_ID", { enumerable: true, get: function () { return constants_js_1.DEFAULT_MINIMA_TOKEN_ID; } });
+Object.defineProperty(exports, "PROVIDER_BOND_TOPIC_PREFIX", { enumerable: true, get: function () { return constants_js_1.PROVIDER_BOND_TOPIC_PREFIX; } });
+Object.defineProperty(exports, "DEFAULT_PROVIDER_SCORING_WEIGHTS", { enumerable: true, get: function () { return constants_js_1.DEFAULT_PROVIDER_SCORING_WEIGHTS; } });
+var serialization_js_1 = require("./serialization.js");
+Object.defineProperty(exports, "serializeProviderBondState", { enumerable: true, get: function () { return serialization_js_1.serializeProviderBondState; } });
+Object.defineProperty(exports, "parseProviderBondState", { enumerable: true, get: function () { return serialization_js_1.parseProviderBondState; } });
+Object.defineProperty(exports, "serializeProviderBondRecord", { enumerable: true, get: function () { return serialization_js_1.serializeProviderBondRecord; } });
+Object.defineProperty(exports, "parseProviderBondRecord", { enumerable: true, get: function () { return serialization_js_1.parseProviderBondRecord; } });
+var manifest_js_1 = require("./manifest.js");
+Object.defineProperty(exports, "createProviderBondManifest", { enumerable: true, get: function () { return manifest_js_1.createProviderBondManifest; } });
+Object.defineProperty(exports, "computeProviderBondExtensionHash", { enumerable: true, get: function () { return manifest_js_1.computeProviderBondExtensionHash; } });
+Object.defineProperty(exports, "computeProviderBondManifestHash", { enumerable: true, get: function () { return manifest_js_1.computeProviderBondManifestHash; } });
+Object.defineProperty(exports, "verifyProviderBondManifest", { enumerable: true, get: function () { return manifest_js_1.verifyProviderBondManifest; } });
+Object.defineProperty(exports, "assertManifestNotExpired", { enumerable: true, get: function () { return manifest_js_1.assertManifestNotExpired; } });
+var identity_js_1 = require("./identity.js");
+Object.defineProperty(exports, "bindProviderManifestToIdentity", { enumerable: true, get: function () { return identity_js_1.bindProviderManifestToIdentity; } });
+Object.defineProperty(exports, "verifyProviderManifestIdentity", { enumerable: true, get: function () { return identity_js_1.verifyProviderManifestIdentity; } });
+Object.defineProperty(exports, "verifyProviderBondAddresses", { enumerable: true, get: function () { return identity_js_1.verifyProviderBondAddresses; } });
+Object.defineProperty(exports, "assertProviderControlsAddress", { enumerable: true, get: function () { return identity_js_1.assertProviderControlsAddress; } });
+var bond_proof_js_1 = require("./bond-proof.js");
+Object.defineProperty(exports, "verifyBondProof", { enumerable: true, get: function () { return bond_proof_js_1.verifyBondProof; } });
+Object.defineProperty(exports, "assertBondMeetsMinimum", { enumerable: true, get: function () { return bond_proof_js_1.assertBondMeetsMinimum; } });
+Object.defineProperty(exports, "verifyBondStack", { enumerable: true, get: function () { return bond_proof_js_1.verifyBondStack; } });
+var probes_js_1 = require("./probes.js");
+Object.defineProperty(exports, "recordProbe", { enumerable: true, get: function () { return probes_js_1.recordProbe; } });
+Object.defineProperty(exports, "recordHeartbeat", { enumerable: true, get: function () { return probes_js_1.recordHeartbeat; } });
+var incidents_js_1 = require("./incidents.js");
+Object.defineProperty(exports, "recordIncident", { enumerable: true, get: function () { return incidents_js_1.recordIncident; } });
+Object.defineProperty(exports, "acknowledgeIncident", { enumerable: true, get: function () { return incidents_js_1.acknowledgeIncident; } });
+Object.defineProperty(exports, "resolveIncident", { enumerable: true, get: function () { return incidents_js_1.resolveIncident; } });
+Object.defineProperty(exports, "rejectIncident", { enumerable: true, get: function () { return incidents_js_1.rejectIncident; } });
+var scoring_js_1 = require("./scoring.js");
+Object.defineProperty(exports, "computeProviderScore", { enumerable: true, get: function () { return scoring_js_1.computeProviderScore; } });
+Object.defineProperty(exports, "computeProviderRecommendation", { enumerable: true, get: function () { return scoring_js_1.computeProviderRecommendation; } });
+var policy_js_1 = require("./policy.js");
+Object.defineProperty(exports, "filterProvidersByPolicy", { enumerable: true, get: function () { return policy_js_1.filterProvidersByPolicy; } });
+Object.defineProperty(exports, "rankProvidersByPolicy", { enumerable: true, get: function () { return policy_js_1.rankProvidersByPolicy; } });
+Object.defineProperty(exports, "explainProviderPolicyMatch", { enumerable: true, get: function () { return policy_js_1.explainProviderPolicyMatch; } });
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "createEmptyProviderBondRegistryState", { enumerable: true, get: function () { return registry_js_1.createEmptyProviderBondRegistryState; } });
+Object.defineProperty(exports, "registerProvider", { enumerable: true, get: function () { return registry_js_1.registerProvider; } });
+Object.defineProperty(exports, "updateProviderManifest", { enumerable: true, get: function () { return registry_js_1.updateProviderManifest; } });
+Object.defineProperty(exports, "attachBondProof", { enumerable: true, get: function () { return registry_js_1.attachBondProof; } });
+Object.defineProperty(exports, "recordProviderProbe", { enumerable: true, get: function () { return registry_js_1.recordProviderProbe; } });
+Object.defineProperty(exports, "recordProviderIncident", { enumerable: true, get: function () { return registry_js_1.recordProviderIncident; } });
+Object.defineProperty(exports, "updateProviderScore", { enumerable: true, get: function () { return registry_js_1.updateProviderScore; } });
+Object.defineProperty(exports, "listProviders", { enumerable: true, get: function () { return registry_js_1.listProviders; } });
+Object.defineProperty(exports, "getProvider", { enumerable: true, get: function () { return registry_js_1.getProvider; } });
+Object.defineProperty(exports, "listProvidersByServiceType", { enumerable: true, get: function () { return registry_js_1.listProvidersByServiceType; } });
+Object.defineProperty(exports, "listRiskyProviders", { enumerable: true, get: function () { return registry_js_1.listRiskyProviders; } });
+Object.defineProperty(exports, "listOfflineProviders", { enumerable: true, get: function () { return registry_js_1.listOfflineProviders; } });
+var memory_store_js_1 = require("./memory-store.js");
+Object.defineProperty(exports, "MemoryProviderBondStore", { enumerable: true, get: function () { return memory_store_js_1.MemoryProviderBondStore; } });

package/dist/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderBondManifest, ProviderBondExtension, ProviderBondVerifyResult, CreateProviderBondManifestParams, VerifyProviderBondManifestParams } from './types.js';
+export declare function createProviderBondManifest(params: CreateProviderBondManifestParams): ProviderBondManifest;
+export declare function computeProviderBondExtensionHash(extension: ProviderBondExtension): string;
+export declare function computeProviderBondManifestHash(manifest: ProviderBondManifest): string;
+export declare function verifyProviderBondManifest(params: VerifyProviderBondManifestParams): ProviderBondVerifyResult;
+export declare function assertManifestNotExpired(manifest: ProviderBondManifest, now?: number): void;

package/dist/manifest.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProviderBondManifest = createProviderBondManifest;
+exports.computeProviderBondExtensionHash = computeProviderBondExtensionHash;
+exports.computeProviderBondManifestHash = computeProviderBondManifestHash;
+exports.verifyProviderBondManifest = verifyProviderBondManifest;
+exports.assertManifestNotExpired = assertManifestNotExpired;
+const core_1 = require("@totemsdk/core");
+const manifest_1 = require("@totemsdk/manifest");
+const errors_js_1 = require("./errors.js");
+const serialization_js_1 = require("./serialization.js");
+function hexToBytes(hex) {
+    return (0, core_1.hexToBytes)(hex);
+}
+function bytesToHex(bytes) {
+    return (0, core_1.bytesToHex)(bytes);
+}
+function createProviderBondManifest(params) {
+    const edgeServiceManifestId = (0, manifest_1.computeManifestId)(params.edgeService);
+    return {
+        edgeServiceManifestId,
+        edgeService: params.edgeService,
+        signedEdgeService: params.signedEdgeService,
+        providerBond: params.providerBond,
+    };
+}
+function computeProviderBondExtensionHash(extension) {
+    const { extensionHash, ...rest } = extension;
+    const json = (0, serialization_js_1.canonicalJson)(rest);
+    return bytesToHex((0, core_1.F)(new TextEncoder().encode(json)));
+}
+function computeProviderBondManifestHash(manifest) {
+    const { signedEdgeService, ...rest } = manifest;
+    const json = (0, serialization_js_1.canonicalJson)(rest);
+    return bytesToHex((0, core_1.F)(new TextEncoder().encode(json)));
+}
+function verifyProviderBondManifest(params) {
+    const { manifest, now } = params;
+    if (manifest.signedEdgeService) {
+        const result = (0, manifest_1.verifyManifest)(manifest.signedEdgeService);
+        if (!result.valid) {
+            return { ok: false, reason: result.reason || 'Manifest signature invalid', code: 'MANIFEST_SIGNATURE_INVALID' };
+        }
+    }
+    if (now !== undefined && manifest.edgeService.expiresAt !== undefined && manifest.edgeService.expiresAt < now) {
+        return { ok: false, reason: 'Manifest has expired', code: 'MANIFEST_EXPIRED' };
+    }
+    if (manifest.providerBond.extensionHash) {
+        const computed = computeProviderBondExtensionHash(manifest.providerBond);
+        if (computed !== manifest.providerBond.extensionHash) {
+            return { ok: false, reason: 'Provider bond extension hash mismatch', code: 'BOND_EXTENSION_HASH_MISMATCH' };
+        }
+    }
+    return { ok: true, code: 'OK' };
+}
+function assertManifestNotExpired(manifest, now) {
+    const ts = now ?? Date.now();
+    if (manifest.edgeService.expiresAt !== undefined && manifest.edgeService.expiresAt < ts) {
+        throw new errors_js_1.ProviderManifestError('Manifest has expired', 'MANIFEST_EXPIRED');
+    }
+}

package/dist/memory-store.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderBondManifest, ProviderBondRegistryState, BondProofRef, ProbeResult, IncidentRecord, ProviderScore } from './types.js';
+export declare class MemoryProviderBondStore {
+    private state;
+    constructor();
+    registerProvider(manifest: ProviderBondManifest): Promise<void>;
+    updateProviderManifest(manifest: ProviderBondManifest): Promise<void>;
+    attachBondProof(providerId: string, proof: BondProofRef): Promise<void>;
+    recordProbe(providerId: string, probe: ProbeResult): Promise<void>;
+    recordIncident(providerId: string, incident: IncidentRecord): Promise<void>;
+    updateScore(providerId: string, score: ProviderScore): Promise<void>;
+    listProviders(): Promise<ProviderBondManifest[]>;
+    getProvider(providerId: string): Promise<ProviderBondManifest | undefined>;
+    listProvidersByServiceType(serviceType: string): Promise<ProviderBondManifest[]>;
+    listRiskyProviders(threshold: number): Promise<ProviderBondManifest[]>;
+    listOfflineProviders(maxHeartbeatAgeMs: number, now: number): Promise<ProviderBondManifest[]>;
+    getSnapshot(): Promise<ProviderBondRegistryState>;
+}

package/dist/memory-store.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryProviderBondStore = void 0;
+const registry_js_1 = require("./registry.js");
+class MemoryProviderBondStore {
+    constructor() {
+        this.state = (0, registry_js_1.createEmptyProviderBondRegistryState)();
+    }
+    async registerProvider(manifest) {
+        this.state = (0, registry_js_1.registerProvider)(this.state, manifest);
+    }
+    async updateProviderManifest(manifest) {
+        this.state = (0, registry_js_1.updateProviderManifest)(this.state, manifest);
+    }
+    async attachBondProof(providerId, proof) {
+        this.state = (0, registry_js_1.attachBondProof)(this.state, providerId, proof);
+    }
+    async recordProbe(providerId, probe) {
+        this.state = (0, registry_js_1.recordProviderProbe)(this.state, providerId, probe);
+    }
+    async recordIncident(providerId, incident) {
+        this.state = (0, registry_js_1.recordProviderIncident)(this.state, providerId, incident);
+    }
+    async updateScore(providerId, score) {
+        this.state = (0, registry_js_1.updateProviderScore)(this.state, providerId, score);
+    }
+    async listProviders() {
+        return (0, registry_js_1.listProviders)(this.state);
+    }
+    async getProvider(providerId) {
+        return (0, registry_js_1.getProvider)(this.state, providerId);
+    }
+    async listProvidersByServiceType(serviceType) {
+        return (0, registry_js_1.listProvidersByServiceType)(this.state, serviceType);
+    }
+    async listRiskyProviders(threshold) {
+        return (0, registry_js_1.listRiskyProviders)(this.state, threshold);
+    }
+    async listOfflineProviders(maxHeartbeatAgeMs, now) {
+        return (0, registry_js_1.listOfflineProviders)(this.state, maxHeartbeatAgeMs, now);
+    }
+    async getSnapshot() {
+        return JSON.parse(JSON.stringify(this.state, (_, v) => typeof v === 'bigint' ? v.toString() : v));
+    }
+}
+exports.MemoryProviderBondStore = MemoryProviderBondStore;

package/dist/policy.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderBondRegistryState, ProviderPolicy, PolicyMatch } from './types.js';
+export declare function filterProvidersByPolicy(state: ProviderBondRegistryState, policy: ProviderPolicy): PolicyMatch[];
+export declare function rankProvidersByPolicy(matches: PolicyMatch[]): PolicyMatch[];
+export declare function explainProviderPolicyMatch(match: PolicyMatch): string[];

package/dist/policy.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterProvidersByPolicy = filterProvidersByPolicy;
+exports.rankProvidersByPolicy = rankProvidersByPolicy;
+exports.explainProviderPolicyMatch = explainProviderPolicyMatch;
+function filterProvidersByPolicy(state, policy) {
+    const providers = Object.values(state.providers);
+    const now = policy.now ?? Date.now();
+    return providers.map((provider) => {
+        const reasons = [];
+        const failures = [];
+        const score = state.scores[provider.providerBond.providerId];
+        if (policy.serviceType && provider.edgeService.serviceType !== policy.serviceType) {
+            failures.push(`Service type ${provider.edgeService.serviceType} does not match required ${policy.serviceType}`);
+        }
+        if (policy.minScore !== undefined && score) {
+            if (score.score < policy.minScore) {
+                failures.push(`Score ${score.score} is below minimum ${policy.minScore}`);
+            }
+            else {
+                reasons.push(`Score ${score.score} meets minimum ${policy.minScore}`);
+            }
+        }
+        if (policy.requireIdentity) {
+            if (!provider.providerBond.bondOwnerAddress) {
+                failures.push('Identity not declared');
+            }
+            else {
+                reasons.push('Identity declared');
+            }
+        }
+        if (policy.requireActiveBond) {
+            const hasActiveBond = provider.providerBond.bondStack?.some((d) => d.status === 'active');
+            if (!hasActiveBond) {
+                failures.push('No active bond');
+            }
+            else {
+                reasons.push('Active bond present');
+            }
+        }
+        if (policy.requireMinimaHardCollateral) {
+            const hasMinimaHardCollateral = provider.providerBond.bondStack?.some((d) => d.asset === 'MINIMA' && d.purpose === 'hard-collateral' && d.status === 'active');
+            if (!hasMinimaHardCollateral) {
+                failures.push('No active MINIMA hard-collateral bond');
+            }
+            else {
+                reasons.push('MINIMA hard-collateral bond present');
+            }
+        }
+        if (policy.minBondAmount !== undefined) {
+            const totalBond = provider.providerBond.bondStack?.reduce((sum, d) => sum + d.amount, 0n) ?? 0n;
+            if (totalBond < policy.minBondAmount) {
+                failures.push(`Total bond ${totalBond.toString()} is below minimum ${policy.minBondAmount.toString()}`);
+            }
+            else {
+                reasons.push(`Total bond ${totalBond.toString()} meets minimum ${policy.minBondAmount.toString()}`);
+            }
+        }
+        if (policy.acceptedAssets && policy.acceptedAssets.length > 0) {
+            const bondAssets = new Set(provider.providerBond.bondStack?.map((d) => d.asset) ?? []);
+            const hasAccepted = policy.acceptedAssets.some((a) => bondAssets.has(a));
+            if (!hasAccepted) {
+                failures.push('No bond in accepted assets');
+            }
+            else {
+                reasons.push('Bond asset accepted');
+            }
+        }
+        if (policy.acceptedPurposes && policy.acceptedPurposes.length > 0) {
+            const bondPurposes = new Set(provider.providerBond.bondStack?.map((d) => d.purpose) ?? []);
+            const hasAccepted = policy.acceptedPurposes.some((p) => bondPurposes.has(p));
+            if (!hasAccepted) {
+                failures.push('No bond with accepted purpose');
+            }
+            else {
+                reasons.push('Bond purpose accepted');
+            }
+        }
+        if (policy.maxIncidentSeverity) {
+            const providerIncidents = state.incidents[provider.providerBond.providerId] ?? [];
+            const severityOrder = { low: 0, medium: 1, high: 2, critical: 3 };
+            const maxSeen = providerIncidents.reduce((max, i) => {
+                const s = severityOrder[i.severity] ?? 0;
+                return s > max ? s : max;
+            }, 0);
+            const policyMax = severityOrder[policy.maxIncidentSeverity] ?? 0;
+            if (maxSeen > policyMax) {
+                failures.push(`Incident severity exceeds policy maximum`);
+            }
+            else {
+                reasons.push('Incident severity within policy limits');
+            }
+        }
+        if (policy.maxHeartbeatAgeMs !== undefined) {
+            const providerProbes = state.probes[provider.providerBond.providerId] ?? [];
+            const heartbeats = providerProbes.filter((p) => p.type === 'heartbeat');
+            const lastHeartbeat = heartbeats.length > 0
+                ? heartbeats.reduce((max, h) => h.observedAt > max ? h.observedAt : max, 0)
+                : 0;
+            if (now - lastHeartbeat > policy.maxHeartbeatAgeMs) {
+                failures.push(`Last heartbeat too old (${now - lastHeartbeat}ms > ${policy.maxHeartbeatAgeMs}ms)`);
+            }
+            else if (lastHeartbeat > 0) {
+                reasons.push('Heartbeat is recent');
+            }
+        }
+        return {
+            providerId: provider.providerBond.providerId,
+            provider,
+            matched: failures.length === 0,
+            score,
+            reasons,
+            failures,
+        };
+    });
+}
+function rankProvidersByPolicy(matches) {
+    return [...matches].sort((a, b) => {
+        if (a.matched && !b.matched)
+            return -1;
+        if (!a.matched && b.matched)
+            return 1;
+        const scoreA = a.score?.score ?? 0;
+        const scoreB = b.score?.score ?? 0;
+        return scoreB - scoreA;
+    });
+}
+function explainProviderPolicyMatch(match) {
+    const lines = [];
+    lines.push(`Provider: ${match.providerId}`);
+    lines.push(`Matched: ${match.matched}`);
+    if (match.score) {
+        lines.push(`Score: ${match.score.score} (${match.score.recommendation})`);
+    }
+    if (match.reasons.length > 0) {
+        lines.push('Passed checks:');
+        for (const r of match.reasons)
+            lines.push(`  + ${r}`);
+    }
+    if (match.failures.length > 0) {
+        lines.push('Failed checks:');
+        for (const f of match.failures)
+            lines.push(`  - ${f}`);
+    }
+    return lines;
+}

package/dist/probes.d.ts

@@ -0,0 +1,3 @@
+import type { ProbeResult, RecordProbeParams } from './types.js';
+export declare function recordProbe(params: RecordProbeParams): ProbeResult;
+export declare function recordHeartbeat(providerId: string, now?: number): ProbeResult;

package/dist/probes.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordProbe = recordProbe;
+exports.recordHeartbeat = recordHeartbeat;
+let probeCounter = 0;
+function recordProbe(params) {
+    const now = params.now ?? Date.now();
+    probeCounter++;
+    return {
+        probeId: `probe-${now}-${probeCounter}`,
+        providerId: params.providerId,
+        type: params.type,
+        ok: params.ok,
+        latencyMs: params.latencyMs,
+        observedAt: now,
+        message: params.message,
+        metadata: params.metadata,
+    };
+}
+function recordHeartbeat(providerId, now) {
+    return recordProbe({
+        providerId,
+        type: 'heartbeat',
+        ok: true,
+        now,
+    });
+}

package/dist/registry.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderBondRegistryState, ProviderBondManifest, BondProofRef, ProbeResult, IncidentRecord, ProviderScore } from './types.js';
+export declare function createEmptyProviderBondRegistryState(): ProviderBondRegistryState;
+export declare function registerProvider(state: ProviderBondRegistryState, manifest: ProviderBondManifest): ProviderBondRegistryState;
+export declare function updateProviderManifest(state: ProviderBondRegistryState, manifest: ProviderBondManifest): ProviderBondRegistryState;
+export declare function attachBondProof(state: ProviderBondRegistryState, providerId: string, proof: BondProofRef): ProviderBondRegistryState;
+export declare function recordProviderProbe(state: ProviderBondRegistryState, providerId: string, probe: ProbeResult): ProviderBondRegistryState;
+export declare function recordProviderIncident(state: ProviderBondRegistryState, providerId: string, incident: IncidentRecord): ProviderBondRegistryState;
+export declare function updateProviderScore(state: ProviderBondRegistryState, providerId: string, score: ProviderScore): ProviderBondRegistryState;
+export declare function listProviders(state: ProviderBondRegistryState): ProviderBondManifest[];
+export declare function getProvider(state: ProviderBondRegistryState, providerId: string): ProviderBondManifest | undefined;
+export declare function listProvidersByServiceType(state: ProviderBondRegistryState, serviceType: string): ProviderBondManifest[];
+export declare function listRiskyProviders(state: ProviderBondRegistryState, threshold: number): ProviderBondManifest[];
+export declare function listOfflineProviders(state: ProviderBondRegistryState, maxHeartbeatAgeMs: number, now: number): ProviderBondManifest[];

package/dist/registry.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptyProviderBondRegistryState = createEmptyProviderBondRegistryState;
+exports.registerProvider = registerProvider;
+exports.updateProviderManifest = updateProviderManifest;
+exports.attachBondProof = attachBondProof;
+exports.recordProviderProbe = recordProviderProbe;
+exports.recordProviderIncident = recordProviderIncident;
+exports.updateProviderScore = updateProviderScore;
+exports.listProviders = listProviders;
+exports.getProvider = getProvider;
+exports.listProvidersByServiceType = listProvidersByServiceType;
+exports.listRiskyProviders = listRiskyProviders;
+exports.listOfflineProviders = listOfflineProviders;
+function createEmptyProviderBondRegistryState() {
+    return {
+        providers: {},
+        bondProofs: {},
+        probes: {},
+        incidents: {},
+        scores: {},
+        updatedAt: Date.now(),
+    };
+}
+function registerProvider(state, manifest) {
+    const providers = { ...state.providers };
+    providers[manifest.providerBond.providerId] = manifest;
+    return { ...state, providers, updatedAt: Date.now() };
+}
+function updateProviderManifest(state, manifest) {
+    return registerProvider(state, manifest);
+}
+function attachBondProof(state, providerId, proof) {
+    const bondProofs = { ...state.bondProofs };
+    const existing = bondProofs[providerId] ?? [];
+    bondProofs[providerId] = [...existing, proof];
+    return { ...state, bondProofs, updatedAt: Date.now() };
+}
+function recordProviderProbe(state, providerId, probe) {
+    const probes = { ...state.probes };
+    const existing = probes[providerId] ?? [];
+    probes[providerId] = [...existing, probe];
+    return { ...state, probes, updatedAt: Date.now() };
+}
+function recordProviderIncident(state, providerId, incident) {
+    const incidents = { ...state.incidents };
+    const existing = incidents[providerId] ?? [];
+    incidents[providerId] = [...existing, incident];
+    return { ...state, incidents, updatedAt: Date.now() };
+}
+function updateProviderScore(state, providerId, score) {
+    const scores = { ...state.scores };
+    scores[providerId] = score;
+    return { ...state, scores, updatedAt: Date.now() };
+}
+function listProviders(state) {
+    return Object.values(state.providers);
+}
+function getProvider(state, providerId) {
+    return state.providers[providerId];
+}
+function listProvidersByServiceType(state, serviceType) {
+    return Object.values(state.providers).filter((p) => p.edgeService.serviceType === serviceType);
+}
+function listRiskyProviders(state, threshold) {
+    return Object.values(state.providers).filter((p) => {
+        const score = state.scores[p.providerBond.providerId];
+        return score && score.score < threshold;
+    });
+}
+function listOfflineProviders(state, maxHeartbeatAgeMs, now) {
+    return Object.values(state.providers).filter((p) => {
+        const providerProbes = state.probes[p.providerBond.providerId] ?? [];
+        const heartbeats = providerProbes.filter((pr) => pr.type === 'heartbeat');
+        if (heartbeats.length === 0)
+            return true;
+        const lastHeartbeat = heartbeats.reduce((max, h) => h.observedAt > max ? h.observedAt : max, 0);
+        return now - lastHeartbeat > maxHeartbeatAgeMs;
+    });
+}

package/dist/scoring.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderScore, ProviderRecommendation, ComputeProviderScoreParams } from './types.js';
+export declare function computeProviderScore(params: ComputeProviderScoreParams): ProviderScore;
+export declare function computeProviderRecommendation(score: number): ProviderRecommendation;

package/dist/scoring.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeProviderScore = computeProviderScore;
+exports.computeProviderRecommendation = computeProviderRecommendation;
+const constants_js_1 = require("./constants.js");
+function computeProviderScore(params) {
+    const { provider, bondProofs, probes, incidents, now, weights } = params;
+    const w = weights ?? constants_js_1.DEFAULT_PROVIDER_SCORING_WEIGHTS;
+    const ts = now ?? Date.now();
+    const reasons = [];
+    let identityScore = 0;
+    if (provider.providerBond.bondOwnerAddress) {
+        identityScore = 100;
+        reasons.push('Identity address declared');
+    }
+    else {
+        reasons.push('No identity address declared');
+    }
+    let bondScore = 0;
+    const hasBond = provider.providerBond.bondStack && provider.providerBond.bondStack.length > 0;
+    const hasMinimaBond = hasBond && provider.providerBond.bondStack.some((d) => d.asset === 'MINIMA' && d.purpose === 'hard-collateral' && d.status === 'active');
+    const hasProof = bondProofs && bondProofs.length > 0;
+    if (hasMinimaBond && hasProof) {
+        bondScore = 100;
+        reasons.push('Active MINIMA hard-collateral bond with proof');
+    }
+    else if (hasMinimaBond) {
+        bondScore = 70;
+        reasons.push('MINIMA bond declared but no proof attached');
+    }
+    else if (hasBond) {
+        bondScore = 40;
+        reasons.push('Bond declared but not MINIMA hard-collateral');
+    }
+    else {
+        reasons.push('No bond declared');
+    }
+    let reliabilityScore = 50;
+    const providerProbes = probes ?? [];
+    if (providerProbes.length > 0) {
+        const recentProbes = providerProbes.filter((p) => ts - p.observedAt < constants_js_1.MAX_HEARTBEAT_AGE_MS_DEFAULT);
+        if (recentProbes.length > 0) {
+            const successRate = recentProbes.filter((p) => p.ok).length / recentProbes.length;
+            const avgLatency = recentProbes.reduce((sum, p) => sum + (p.latencyMs ?? 0), 0) / recentProbes.length;
+            reliabilityScore = successRate * 100;
+            if (avgLatency > 1000)
+                reliabilityScore -= 20;
+            else if (avgLatency > 500)
+                reliabilityScore -= 10;
+            reasons.push(`Probe success rate: ${(successRate * 100).toFixed(0)}%`);
+        }
+        else {
+            reliabilityScore = 0;
+            reasons.push('No recent probes (offline)');
+        }
+    }
+    else {
+        reasons.push('No probe data');
+    }
+    let incidentScore = 100;
+    const providerIncidents = incidents ?? [];
+    if (providerIncidents.length > 0) {
+        const openIncidents = providerIncidents.filter((i) => i.status === 'open');
+        const criticalIncidents = providerIncidents.filter((i) => i.severity === 'critical');
+        const highIncidents = providerIncidents.filter((i) => i.severity === 'high');
+        incidentScore = 100 - (openIncidents.length * 10) - (criticalIncidents.length * 20) - (highIncidents.length * 10);
+        incidentScore = Math.max(0, incidentScore);
+        if (criticalIncidents.length > 0)
+            reasons.push(`${criticalIncidents.length} critical incident(s)`);
+        if (highIncidents.length > 0)
+            reasons.push(`${highIncidents.length} high-severity incident(s)`);
+        if (openIncidents.length > 0)
+            reasons.push(`${openIncidents.length} open incident(s)`);
+    }
+    else {
+        reasons.push('No incidents');
+    }
+    const totalScore = Math.round(identityScore * w.identity +
+        bondScore * w.bond +
+        reliabilityScore * w.reliability +
+        incidentScore * w.incidents);
+    const recommendation = computeProviderRecommendation(totalScore);
+    return {
+        providerId: provider.providerBond.providerId,
+        score: totalScore,
+        recommendation,
+        bondScore,
+        identityScore,
+        reliabilityScore,
+        incidentScore,
+        computedAt: ts,
+        reasons,
+    };
+}
+function computeProviderRecommendation(score) {
+    if (score >= constants_js_1.RECOMMENDATION_THRESHOLDS.recommended)
+        return 'recommended';
+    if (score >= constants_js_1.RECOMMENDATION_THRESHOLDS.acceptable)
+        return 'acceptable';
+    if (score >= constants_js_1.RECOMMENDATION_THRESHOLDS.risky)
+        return 'risky';
+    if (score >= constants_js_1.RECOMMENDATION_THRESHOLDS.avoid)
+        return 'avoid';
+    if (score > 0)
+        return 'unbonded';
+    return 'offline';
+}

package/dist/serialization.d.ts

@@ -0,0 +1,6 @@
+declare function canonicalJson(value: unknown): string;
+export declare function serializeProviderBondState(state: unknown): string;
+export declare function parseProviderBondState<T = unknown>(json: string): T;
+export declare function serializeProviderBondRecord(record: unknown): string;
+export declare function parseProviderBondRecord<T = unknown>(json: string): T;
+export { canonicalJson };