"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.OracleAttestation = void 0;
const bufio_1 = require("@node-dlc/bufio");
const bip_schnorr_1 = require("bip-schnorr");
const MessageType_1 = require("../MessageType");
/**
 * Oracle attestation providing signatures over an outcome value.
 * This represents the oracle's actual attestation to a specific outcome.
 * Updated to match rust-dlc specification with 2-byte count prefixes.
 *
 * An attestation from an oracle providing signatures over an outcome value.
 * This is what the oracle publishes when they want to attest to a specific outcome.
 */
class OracleAttestation {
    constructor() {
        /**
         * The type for oracle_attestation message. oracle_attestation = 55400
         */
        this.type = OracleAttestation.type;
        /** The signatures over the event outcome (64 bytes each, Schnorr format). */
        this.signatures = [];
        /** The set of strings representing the outcome value. */
        this.outcomes = [];
    }
    /**
     * Creates an Attestation from JSON data
     * @param json JSON object representing oracle announcement
     */
    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
    static fromJSON(json) {
        const instance = new OracleAttestation();
        // Handle different field name variations
        instance.eventId = json.eventId;
        instance.oraclePublicKey = Buffer.from(json.oraclePublicKey || json.oraclePubkey || json.oracle_public_key, 'hex');
        instance.signatures = json.signatures.map((signature) => Buffer.from(signature, 'hex'));
        instance.outcomes = json.outcomes;
        return instance;
    }
    /**
     * Deserializes an oracle_attestation message
     * @param buf
     */
    static deserialize(buf) {
        const instance = new OracleAttestation();
        const reader = new bufio_1.BufferReader(buf);
        reader.readBigSize(); // read type
        instance.length = reader.readBigSize();
        // Detect format: old rust-dlc 0.4.0 (no event_id) vs new rust-dlc (with event_id)
        const currentPos = reader.position;
        try {
            // Try reading as new format (with event_id)
            const eventIdLength = reader.readBigSize();
            // If event ID length is reasonable (0-100 bytes), assume new format
            if (eventIdLength >= BigInt('0') && eventIdLength <= BigInt('100')) {
                if (eventIdLength === BigInt('0')) {
                    instance.eventId = '';
                }
                else {
                    const eventIdBuf = reader.readBytes(Number(eventIdLength));
                    instance.eventId = eventIdBuf.toString();
                }
                instance.oraclePublicKey = reader.readBytes(32);
            }
            else {
                // Event ID length is unreasonable, probably old format without event_id
                reader.position = currentPos;
                instance.eventId = ''; // Default empty event ID for old format
                instance.oraclePublicKey = reader.readBytes(32);
            }
        }
        catch (error) {
            // If reading fails, assume old format without event_id
            reader.position = currentPos;
            instance.eventId = ''; // Default empty event ID for old format
            instance.oraclePublicKey = reader.readBytes(32);
        }
        const numSignatures = reader.readUInt16BE();
        for (let i = 0; i < numSignatures; i++) {
            const signature = reader.readBytes(64);
            instance.signatures.push(signature);
        }
        // Handle both rust-dlc format (with u16 count prefix) and DLCSpecs format (no count prefix)
        // Try to detect format by checking if next 2 bytes look like a reasonable outcome count
        if (!reader.eof) {
            const currentPos = reader.position;
            try {
                // Try reading as rust-dlc format (with u16 count prefix)
                const numOutcomes = reader.readUInt16BE();
                // Validate that this looks like a reasonable count
                // If it's > 1000 or the remaining bytes can't accommodate this many outcomes,
                // it's probably not a count prefix
                const remainingBytes = reader.buffer.length - reader.position;
                if (numOutcomes > 0 &&
                    numOutcomes <= 1000 &&
                    remainingBytes >= numOutcomes * 2) {
                    // Looks like rust-dlc format with u16 count prefix
                    for (let i = 0; i < numOutcomes; i++) {
                        const outcomeLen = reader.readBigSize();
                        const outcomeBuf = reader.readBytes(Number(outcomeLen));
                        instance.outcomes.push(outcomeBuf.toString());
                    }
                }
                else {
                    // Reset and try DLCSpecs format (no count prefix)
                    reader.position = currentPos;
                    while (!reader.eof) {
                        const outcomeLen = reader.readBigSize();
                        const outcomeBuf = reader.readBytes(Number(outcomeLen));
                        instance.outcomes.push(outcomeBuf.toString());
                    }
                }
            }
            catch (error) {
                // If reading as rust-dlc format fails, reset and try DLCSpecs format
                reader.position = currentPos;
                while (!reader.eof) {
                    const outcomeLen = reader.readBigSize();
                    const outcomeBuf = reader.readBytes(Number(outcomeLen));
                    instance.outcomes.push(outcomeBuf.toString());
                }
            }
        }
        return instance;
    }
    /**
     * Validates the oracle attestation according to rust-dlc specification.
     * This includes validating signatures and ensuring consistency with announcement.
     * @param announcement The corresponding oracle announcement for validation (optional)
     * @throws Will throw an error if validation fails
     */
    validate(announcement) {
        // Basic structure validation
        if (this.signatures.length !== this.outcomes.length) {
            throw new Error('Number of signatures must match number of outcomes');
        }
        if (this.signatures.length === 0) {
            throw new Error('Must have at least one signature and outcome');
        }
        // Validate event ID
        if (!this.eventId || this.eventId.length === 0) {
            throw new Error('Event ID cannot be empty');
        }
        // Validate oracle public key format
        if (!this.oraclePublicKey || this.oraclePublicKey.length !== 32) {
            throw new Error('Oracle public key must be 32 bytes (x-only format)');
        }
        // Validate signature formats
        this.signatures.forEach((sig, index) => {
            if (!sig || sig.length !== 64) {
                throw new Error(`Signature at index ${index} must be 64 bytes (Schnorr format)`);
            }
        });
        // Validate outcomes are not empty
        this.outcomes.forEach((outcome, index) => {
            if (!outcome || outcome.length === 0) {
                throw new Error(`Outcome at index ${index} cannot be empty`);
            }
        });
        // Verify signatures over outcomes using tagged hash
        this.signatures.forEach((sig, index) => {
            const outcome = this.outcomes[index];
            try {
                const msg = bip_schnorr_1.math.taggedHash('DLC/oracle/attestation/v0', outcome);
                (0, bip_schnorr_1.verify)(this.oraclePublicKey, msg, sig);
            }
            catch (error) {
                throw new Error(`Invalid signature for outcome "${outcome}" at index ${index}: ${error.message}`);
            }
        });
        // If announcement is provided, validate consistency
        if (announcement) {
            this.validateAgainstAnnouncement(announcement);
        }
    }
    /**
     * Validates the attestation against the corresponding oracle announcement.
     * This ensures the attestation is consistent with the original announcement.
     * @param announcement The oracle announcement to validate against
     * @throws Will throw an error if validation fails
     */
    validateAgainstAnnouncement(announcement) {
        // Validate oracle public key matches announcement
        if (!this.oraclePublicKey.equals(announcement.oraclePublicKey)) {
            throw new Error('Oracle public key must match announcement');
        }
        // Validate event ID matches
        if (this.eventId !== announcement.getEventId()) {
            throw new Error('Event ID must match announcement');
        }
        // Validate that the number of signatures matches the number of nonces in announcement
        const announcementNonces = announcement.getNonces();
        if (this.signatures.length !== announcementNonces.length) {
            throw new Error('Number of signatures must match number of nonces in announcement');
        }
        // Extract nonces from signatures (first 32 bytes) and compare with announcement nonces
        // This validates that the signatures were created using the committed nonces
        this.signatures.forEach((sig, index) => {
            const nonceFromSig = sig.slice(0, 32);
            const expectedNonce = announcementNonces[index];
            if (!nonceFromSig.equals(expectedNonce)) {
                throw new Error(`Signature nonce mismatch at index ${index}: signature was not created with announced nonce`);
            }
        });
    }
    /**
     * Returns the nonces used by the oracle to sign the event outcome.
     * This is used for finding the matching oracle announcement.
     * The nonce is extracted from the first 32 bytes of each signature.
     */
    getNonces() {
        return this.signatures.map((sig) => sig.slice(0, 32));
    }
    /**
     * Converts oracle_attestation to JSON
     */
    toJSON() {
        return {
            type: this.type,
            eventId: this.eventId,
            oraclePublicKey: this.oraclePublicKey.toString('hex'),
            signatures: this.signatures.map((sig) => sig.toString('hex')),
            outcomes: this.outcomes,
        };
    }
    /**
     * Serializes the oracle_attestation message into a Buffer
     */
    serialize() {
        const writer = new bufio_1.BufferWriter();
        writer.writeBigSize(this.type);
        const dataWriter = new bufio_1.BufferWriter();
        dataWriter.writeBigSize(this.eventId.length);
        dataWriter.writeBytes(Buffer.from(this.eventId));
        dataWriter.writeBytes(this.oraclePublicKey);
        dataWriter.writeUInt16BE(this.signatures.length);
        for (const signature of this.signatures) {
            dataWriter.writeBytes(signature);
        }
        // Write outcomes with u16 count prefix (matching rust-dlc format)
        dataWriter.writeUInt16BE(this.outcomes.length);
        for (const outcome of this.outcomes) {
            dataWriter.writeBigSize(outcome.length);
            dataWriter.writeBytes(Buffer.from(outcome));
        }
        writer.writeBigSize(dataWriter.size);
        writer.writeBytes(dataWriter.toBuffer());
        return writer.toBuffer();
    }
}
exports.OracleAttestation = OracleAttestation;
OracleAttestation.type = MessageType_1.MessageType.OracleAttestation;
//# sourceMappingURL=OracleAttestation.js.map