@dao-xyz/peerbit/lib/esm/exchange-heads.js

Distributed p2p database on IPFS

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { variant, option, field, vec, serialize, fixedArray, } from "@dao-xyz/borsh";
import { Entry } from "@dao-xyz/peerbit-log";
import { DecryptedThing } from "@dao-xyz/peerbit-crypto";
import { MaybeSigned } from "@dao-xyz/peerbit-crypto";
import { logger as loggerFn } from "@dao-xyz/peerbit-logger";
import { TransportMessage } from "./message.js";
import { v4 as uuid } from "uuid";
const logger = loggerFn({ module: "exchange-heads" });
export class MinReplicas {
    get value() {
        throw new Error("Not implemented");
    }
}
export let AbsolutMinReplicas = class AbsolutMinReplicas extends MinReplicas {
    _value;
    constructor(value) {
        super();
        this._value = value;
    }
    get value() {
        return this._value;
    }
};
AbsolutMinReplicas = __decorate([
    variant(0),
    __metadata("design:paramtypes", [Number])
], AbsolutMinReplicas);
/**
 * This thing allows use to faster sync since we can provide
 * references that can be read concurrently to
 * the entry when doing Log.fromEntry or Log.fromEntryHash
 */
export let EntryWithRefs = class EntryWithRefs {
    entry;
    references; // are some parents to the entry
    constructor(properties) {
        this.entry = properties.entry;
        this.references = properties.references;
    }
};
__decorate([
    field({ type: Entry }),
    __metadata("design:type", Entry)
], EntryWithRefs.prototype, "entry", void 0);
__decorate([
    field({ type: vec(Entry) }),
    __metadata("design:type", Array)
], EntryWithRefs.prototype, "references", void 0);
EntryWithRefs = __decorate([
    variant(0),
    __metadata("design:paramtypes", [Object])
], EntryWithRefs);
export let ExchangeHeadsMessage = class ExchangeHeadsMessage extends TransportMessage {
    logId;
    heads;
    minReplicas;
    reserved = new Uint8Array(4);
    constructor(props) {
        super();
        this.id = uuid();
        this.logId = props.logId;
        this.heads = props.heads;
        this.minReplicas = props.minReplicas;
    }
};
__decorate([
    field({ type: fixedArray("u8", 32) }),
    __metadata("design:type", Uint8Array)
], ExchangeHeadsMessage.prototype, "logId", void 0);
__decorate([
    field({ type: vec(EntryWithRefs) }),
    __metadata("design:type", Array)
], ExchangeHeadsMessage.prototype, "heads", void 0);
__decorate([
    field({ type: option(MinReplicas) }),
    __metadata("design:type", MinReplicas)
], ExchangeHeadsMessage.prototype, "minReplicas", void 0);
__decorate([
    field({ type: fixedArray("u8", 4) }),
    __metadata("design:type", Uint8Array)
], ExchangeHeadsMessage.prototype, "reserved", void 0);
ExchangeHeadsMessage = __decorate([
    variant([0, 0]),
    __metadata("design:paramtypes", [Object])
], ExchangeHeadsMessage);
export let RequestHeadsMessage = class RequestHeadsMessage extends TransportMessage {
    address;
    constructor(props) {
        super();
        if (props) {
            this.address = props.address;
        }
    }
};
__decorate([
    field({ type: "string" }),
    __metadata("design:type", String)
], RequestHeadsMessage.prototype, "address", void 0);
RequestHeadsMessage = __decorate([
    variant([0, 1]),
    __metadata("design:paramtypes", [Object])
], RequestHeadsMessage);
export const createExchangeHeadsMessage = async (log, heads, includeReferences, identity) => {
    const headsSet = new Set(heads);
    const headsWithRefs = await Promise.all(heads.map(async (head) => {
        const refs = !includeReferences
            ? []
            : (await log.getReferenceSamples(head, {
                pointerCount: 8,
                memoryLimit: 1e6 / heads.length,
            })) // 1mb total limit split on all heads
                .filter((r) => !headsSet.has(r)); // pick a proportional amount of refs so we can efficiently load the log. TODO should be equidistant for good performance?
        return new EntryWithRefs({
            entry: head,
            references: refs,
        });
    }));
    logger.debug(`Send latest heads of '${log.id}'`);
    const message = new ExchangeHeadsMessage({
        logId: log.id,
        heads: headsWithRefs,
    });
    const maybeSigned = new MaybeSigned({ data: serialize(message) });
    let signedMessage = maybeSigned;
    if (identity) {
        signedMessage = await signedMessage.sign(identity.sign.bind(identity));
    }
    const decryptedMessage = new DecryptedThing({
        data: serialize(signedMessage),
    }); // TODO encryption?
    return serialize(decryptedMessage);
};
//# sourceMappingURL=exchange-heads.js.map