@super-protocol/sdk-js 2.1.2 → 2.1.3

package/dist/mjs/staticModels/TeeOffers.js

@@ -0,0 +1,309 @@
+import rootLogger from '../logger.js';
+import { checkIfActionAccountInitialized, cleanWeb3Data, convertBigIntToString, convertTeeOfferOptionFromRaw, packDeviceId, unpackSlotInfo, convertOptionInfoToRaw, } from '../utils/helper.js';
+import { formatBytes32String, parseBytes32String } from 'ethers/lib/utils.js';
+import { OfferType, } from '../types/index.js';
+import { BlockchainConnector, BlockchainEventsListener } from '../connectors/index.js';
+import Superpro from './Superpro.js';
+import TxManager from '../utils/TxManager.js';
+import StaticModel from './StaticModel.js';
+class TeeOffers {
+    static coresDenominator;
+    static logger = rootLogger.child({ className: 'TeeOffers' });
+    static teeOffers = [];
+    static get address() {
+        return Superpro.address;
+    }
+    static async packHardwareInfo(hw) {
+        const denominator = await TeeOffers.getDenominator();
+        hw.slotInfo.cpuCores *= denominator;
+        hw.slotInfo.gpuCores *= denominator;
+        return hw;
+    }
+    static async unpackHardwareInfo(hw) {
+        const coresDenominator = await TeeOffers.getDenominator();
+        hw.slotInfo = unpackSlotInfo(hw.slotInfo, coresDenominator);
+        return hw;
+    }
+    static async getDenominator() {
+        if (!this.coresDenominator) {
+            const contract = BlockchainConnector.getInstance().getContract();
+            this.coresDenominator = Number(await contract.methods.getCpuDenominator().call());
+        }
+        return this.coresDenominator;
+    }
+    /**
+     * Function for fetching list of all TEE offers addresses
+     */
+    static async getAll() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        const count = Number(await contract.methods.getOffersTotalCount().call());
+        const teeOfffersSet = new Set(this.teeOffers);
+        for (let offerId = teeOfffersSet.size + 1; offerId <= count; ++offerId) {
+            const offerType = (await contract.methods.getOfferType(offerId).call()).toString();
+            if (offerType === OfferType.TeeOffer) {
+                teeOfffersSet.add(offerId.toString());
+            }
+        }
+        this.teeOffers = Array.from(teeOfffersSet);
+        return this.teeOffers;
+    }
+    /**
+     * Creates new TEE offer
+     * @param providerAuthorityAccount - address of authority account of provider
+     * @param teeOfferInfo - data of new TEE offer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async create(providerAuthorityAccount, teeOfferInfo, 
+    // slotInfo: SlotInfo,
+    // optionInfo: OptionInfo,
+    externalId = 'default', enabled = true, transactionOptions) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        checkIfActionAccountInitialized(transactionOptions);
+        // Converts offer info to array of arrays (used in blockchain)
+        teeOfferInfo.hardwareInfo = await TeeOffers.packHardwareInfo(teeOfferInfo.hardwareInfo);
+        const formattedExternalId = formatBytes32String(externalId);
+        await TxManager.execute(contract.methods.createTeeOffer(providerAuthorityAccount, teeOfferInfo, teeOfferInfo.hardwareInfo.slotInfo, convertOptionInfoToRaw(teeOfferInfo.hardwareInfo.optionInfo), formattedExternalId, enabled), transactionOptions);
+    }
+    static async getByExternalId(filter, fromBlock, toBlock) {
+        const founded = await StaticModel.findItemsById('TeeOfferCreated', filter, fromBlock, toBlock);
+        if (!founded)
+            return null;
+        return founded;
+    }
+    /**
+     * Function for fetching TEE offer id by TEE deviceId
+     * @param deviceId - unque TEE device id (unparsed, from blockchain)
+     * @returns TEE offer id
+     */
+    static getByDeviceId(deviceId) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        const fromattedDeviceId = packDeviceId(deviceId);
+        return contract.methods.getTeeOfferByDeviceId(fromattedDeviceId).call();
+    }
+    /**
+     * Function for fetching total count of tee offer slots
+     */
+    static async getSlotsCount() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return Number(await contract.methods.getTeeOffersSlotsCountTotal().call());
+    }
+    /**
+     * Function for fetching whether tee offer option exists or not
+     * @param optionId - Option ID
+     */
+    static isOptionExists(optionId) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return contract.methods.isOptionExists(optionId).call();
+    }
+    /**
+     * Function for fetching total count of options
+     */
+    static async getOptionsCount() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return Number(await contract.methods.getOptionsCount().call());
+    }
+    /**
+     * Function for fetching tee offer option by id
+     * @param optionId - Option ID
+     */
+    static async getOptionById(optionId) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return await contract.methods
+            .getOptionById(optionId)
+            .call()
+            .then((option) => convertTeeOfferOptionFromRaw(option));
+    }
+    static async getSlotByExternalId(filter, fromBlock, toBlock) {
+        const founded = await StaticModel.findItemsById('TeeSlotAdded', filter, fromBlock, toBlock);
+        if (!founded)
+            return null;
+        return founded;
+    }
+    static async getOptionByExternalId(filter, fromBlock, toBlock) {
+        const founded = await StaticModel.findItemsById('OptionAdded', filter, fromBlock, toBlock);
+        if (!founded)
+            return null;
+        return founded;
+    }
+    /**
+     * Function for adding event listeners on onSlotAdded event in contract
+     * @param creator - creator address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotAdded(callback, creator) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onTeeSlotAdded' });
+        const subscription = contract.events.TeeSlotAdded();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (creator && parsedEvent.creator != creator) {
+                return;
+            }
+            callback(parsedEvent.creator, parsedEvent.offerId, parsedEvent.slotId, parseBytes32String(parsedEvent.externalId), {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on onSlotUpdated event in contract
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotUpdated(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onTeeSlotUpdated' });
+        const subscription = contract.events.TeeSlotUpdated();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.offerId, parsedEvent.slotId, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on onSlotDeleted event in contract
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onSlotDeleted(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onTeeSlotDeleted' });
+        const subscription = contract.events.TeeSlotDeleted();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.offerId, parsedEvent.slotId, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on OptionAdded event in contract
+     * @param creator - creator address
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onOptionAdded(callback, creator) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onTeeOptionAddedCallback' });
+        const subscription = contract.events.OptionAdded();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (creator && parsedEvent.creator != creator) {
+                return;
+            }
+            callback(parsedEvent.creator, parsedEvent.teeOfferId, parsedEvent.optionId, parseBytes32String(parsedEvent.externalId), {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on OptionUpdated event in contract
+     * @param teeOfferId - tee offer id
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onOptionUpdated(callback, teeOfferId) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onTeeOptionUpdatedCallback' });
+        const subscription = contract.events.OptionUpdated();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (teeOfferId && event.returnValues.teeOfferId != convertBigIntToString(teeOfferId)) {
+                return;
+            }
+            callback(parsedEvent.teeOfferId, parsedEvent.optionId, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on OptionDeleted event in contract
+     * @param teeOfferId - tee offer id
+     * @param callback - function for processing created order
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onOptionDeleted(callback, teeOfferId) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onTeeOptionDeletedCallback' });
+        const subscription = contract.events.OptionDeleted();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            if (teeOfferId && parsedEvent.teeOfferId != convertBigIntToString(teeOfferId)) {
+                return;
+            }
+            callback(parsedEvent.teeOfferId, parsedEvent.optionId, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * Function for adding event listeners on TEE offer created event in TEE offers factory contract
+     * @param callback - function for processing created TEE offer
+     * @returns unsubscribe - unsubscribe function from event
+     */
+    static onCreated(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onTeeOfferCreated' });
+        const subscription = contract.events.TeeOfferCreated();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.offerId, parsedEvent.creator, parseBytes32String(parsedEvent.externalId), {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+    static onViolationRateChanged(callback) {
+        const contract = BlockchainEventsListener.getInstance().getContract();
+        const logger = this.logger.child({ method: 'onTeeOfferViolationRateChanged' });
+        const subscription = contract.events.TeeOfferViolationRateChanged();
+        subscription.on('data', (event) => {
+            const parsedEvent = cleanWeb3Data(event.returnValues);
+            callback(parsedEvent.offerId, parsedEvent.providerAuth, parsedEvent.violationRate, {
+                index: Number(event.blockNumber),
+                hash: event.blockHash,
+            });
+        });
+        subscription.on('error', (error) => {
+            logger.warn(error);
+        });
+        return () => subscription.unsubscribe();
+    }
+}
+export default TeeOffers;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TeeOffers.js","sourceRoot":"","sources":["../../../src/staticModels/TeeOffers.ts"],"names":[],"mappings":"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"}

package/dist/mjs/store.d.ts

@@ -0,0 +1,15 @@
+import Web3 from 'web3';
+export type Store = {
+    web3Wss?: Web3;
+    web3Https?: Web3;
+    actionAccount?: string;
+    gasLimit: bigint;
+    gasLimitMultiplier: number;
+    gasPriceMultiplier: number;
+    gasPrice?: bigint;
+    txConcurrency: number;
+    txIntervalMs: number;
+    keys: Record<string, string>;
+};
+declare const store: Store;
+export default store;

package/dist/mjs/store.js

@@ -0,0 +1,15 @@
+import { defaultGasLimitMultiplier, defaultGasPriceMultiplier, defaultGasLimit, txIntervalMs, txConcurrency, } from './constants.js';
+const store = {
+    web3Wss: undefined,
+    web3Https: undefined,
+    actionAccount: undefined,
+    gasLimit: defaultGasLimit,
+    gasLimitMultiplier: defaultGasLimitMultiplier,
+    gasPriceMultiplier: defaultGasPriceMultiplier,
+    gasPrice: undefined,
+    txConcurrency: txConcurrency,
+    txIntervalMs: txIntervalMs,
+    keys: {},
+};
+export default store;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLHlCQUF5QixFQUN6Qix5QkFBeUIsRUFDekIsZUFBZSxFQUNmLFlBQVksRUFDWixhQUFhLEdBQ2QsTUFBTSxnQkFBZ0IsQ0FBQztBQWV4QixNQUFNLEtBQUssR0FBVTtJQUNuQixPQUFPLEVBQUUsU0FBUztJQUNsQixTQUFTLEVBQUUsU0FBUztJQUNwQixhQUFhLEVBQUUsU0FBUztJQUN4QixRQUFRLEVBQUUsZUFBZTtJQUN6QixrQkFBa0IsRUFBRSx5QkFBeUI7SUFDN0Msa0JBQWtCLEVBQUUseUJBQXlCO0lBQzdDLFFBQVEsRUFBRSxTQUFTO0lBQ25CLGFBQWEsRUFBRSxhQUFhO0lBQzVCLFlBQVksRUFBRSxZQUFZO0lBQzFCLElBQUksRUFBRSxFQUFFO0NBQ1QsQ0FBQztBQUVGLGVBQWUsS0FBSyxDQUFDIn0=

package/dist/mjs/tee/QuoteParser.d.ts

@@ -0,0 +1,27 @@
+import { BinaryType, TeeSgxQuoteDataType, TeeSgxReportDataType } from './types.js';
+export declare class TeeSgxParser {
+    static readonly quoteHeaderSize = 48;
+    static readonly pceSvnOffset = 10;
+    static readonly reportSize = 384;
+    static readonly userDataOffset = 28;
+    static readonly userDataSize = 20;
+    static readonly cpuSvnSize = 16;
+    static readonly reportMrEnclaveOffset = 64;
+    static readonly reportMrEnclaveSize = 32;
+    static readonly reportMrSignerOffset: number;
+    static readonly reportMrSignerSize = 32;
+    static readonly reportIsvProdIdOffset: number;
+    static readonly reportIsvProdIdSize = 2;
+    static readonly reportIsvSvnOffset: number;
+    static readonly reportIsvSvnSize = 2;
+    static readonly reportDataOffset: number;
+    static readonly reportUserDataSize = 64;
+    static readonly reportUserDataSHA256Size = 32;
+    static readonly ecdsaP256SignatureSize = 64;
+    static readonly ecdsaP256PublicKeySize = 64;
+    private getDataAndAdvance;
+    private extractRS;
+    private parsePem;
+    parseQuote(data: BinaryType): TeeSgxQuoteDataType;
+    parseReport(data: BinaryType): TeeSgxReportDataType;
+}

package/dist/mjs/tee/QuoteParser.js

@@ -0,0 +1,162 @@
+import { Certificate } from '@fidm/x509';
+import * as asn1js from 'asn1js';
+import * as pkijs from 'pkijs';
+import { Buffer as Blob } from 'buffer';
+import { TeeQuoteParserError } from './errors.js';
+import { splitChain, Signature } from './helpers.js';
+export class TeeSgxParser {
+    static quoteHeaderSize = 48;
+    static pceSvnOffset = 10;
+    static reportSize = 384;
+    static userDataOffset = 28;
+    static userDataSize = 20;
+    static cpuSvnSize = 16;
+    static reportMrEnclaveOffset = 64;
+    static reportMrEnclaveSize = 32;
+    static reportMrSignerOffset = TeeSgxParser.reportMrEnclaveOffset + TeeSgxParser.reportMrEnclaveSize + /* reserved */ 32;
+    static reportMrSignerSize = 32;
+    static reportIsvProdIdOffset = TeeSgxParser.reportMrSignerOffset + TeeSgxParser.reportMrSignerSize + /* reserved */ 96;
+    static reportIsvProdIdSize = 2;
+    static reportIsvSvnOffset = TeeSgxParser.reportIsvProdIdOffset + TeeSgxParser.reportIsvProdIdSize;
+    static reportIsvSvnSize = 2;
+    static reportDataOffset = TeeSgxParser.reportIsvSvnOffset + TeeSgxParser.reportIsvSvnSize + /* reserved */ 60;
+    static reportUserDataSize = 64;
+    static reportUserDataSHA256Size = 32; /* 64 in report, but we need 32 only for sha256 hash */
+    static ecdsaP256SignatureSize = 64;
+    static ecdsaP256PublicKeySize = 64;
+    getDataAndAdvance(blob, size) {
+        const buf = Blob.from(blob.data.subarray(0, size));
+        blob.data = Blob.from(blob.data.subarray(size));
+        return buf;
+    }
+    extractRS(cert) {
+        const derSignature = Buffer.from(cert.signatureValue.valueBlock.valueHexView).toString('hex');
+        const parsedSignature = Signature.importFromDER(derSignature);
+        return {
+            r: parsedSignature.r,
+            s: parsedSignature.s,
+            derSignature,
+        };
+    }
+    parsePem(pem) {
+        const cert = Certificate.fromPEM(Buffer.from(pem));
+        const asn1Certificate = asn1js.fromBER(cert.raw);
+        const certificate = new pkijs.Certificate({ schema: asn1Certificate.result });
+        const tbs = certificate.tbsView;
+        const { r, s } = this.extractRS(certificate);
+        const publicKey = cert.publicKey.keyRaw.toString('hex').slice(2);
+        const splitedTbs = Buffer.from(tbs).toString('hex').split(publicKey);
+        const x509PublicKey = '0x' + publicKey;
+        const x509Signature = '0x' + r + s;
+        return {
+            bodyPartOne: '0x' + splitedTbs[0],
+            publicKey: x509PublicKey,
+            bodyPartTwo: '0x' + splitedTbs[1],
+            signature: x509Signature,
+        };
+    }
+    parseQuote(data) {
+        const { quoteHeaderSize, pceSvnOffset, reportSize, userDataOffset, userDataSize, ecdsaP256SignatureSize, ecdsaP256PublicKeySize, } = TeeSgxParser;
+        if (data.length < quoteHeaderSize + reportSize) {
+            throw new TeeQuoteParserError('data has invalid length');
+        }
+        const quoteRemainder = { data: Blob.from(data) };
+        const quoteHeader = this.getDataAndAdvance(quoteRemainder, quoteHeaderSize);
+        const report = this.getDataAndAdvance(quoteRemainder, reportSize);
+        const version = quoteHeader.readUInt16LE(0);
+        const attestationKeyType = quoteHeader.readUInt16LE(2);
+        if (attestationKeyType > 3) {
+            throw new TeeQuoteParserError('quote header has invalid or unsupported attestation key type');
+        }
+        const pceSvn = quoteHeader.readUInt16LE(pceSvnOffset);
+        const userData = quoteHeader.slice(userDataOffset, userDataOffset + userDataSize);
+        const quoteSignatureDateLen = quoteRemainder.data.readUInt32LE(0);
+        quoteRemainder.data = Blob.from(quoteRemainder.data.subarray(4));
+        if (quoteSignatureDateLen != quoteRemainder.data.length) {
+            throw new TeeQuoteParserError(`quoteSignatureDateLen has invalid length: ${quoteRemainder.data.length} instead of ${quoteSignatureDateLen} expected`);
+        }
+        const rawQuoteSignatureDataRemainder = {
+            data: this.getDataAndAdvance(quoteRemainder, quoteSignatureDateLen),
+        };
+        const isvEnclaveReportSignature = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, ecdsaP256SignatureSize);
+        const ecdsaAttestationKey = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, ecdsaP256PublicKeySize);
+        const qeReport = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, reportSize);
+        const qeReportSignature = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, ecdsaP256SignatureSize);
+        const qeAuthenticationDataSize = rawQuoteSignatureDataRemainder.data.readUInt16LE(0);
+        rawQuoteSignatureDataRemainder.data = Blob.from(rawQuoteSignatureDataRemainder.data.subarray(2));
+        if (rawQuoteSignatureDataRemainder.data.length < qeAuthenticationDataSize) {
+            throw new TeeQuoteParserError(`qeAuthenticationDataSize has invalid length: ${rawQuoteSignatureDataRemainder.data.length} instead of ${qeAuthenticationDataSize} expected`);
+        }
+        const qeAuthenticationData = this.getDataAndAdvance(rawQuoteSignatureDataRemainder, qeAuthenticationDataSize);
+        const qeCertificationDataType = rawQuoteSignatureDataRemainder.data.readUInt16LE(0);
+        if (qeCertificationDataType < 1 || qeCertificationDataType > 7) {
+            throw new TeeQuoteParserError(`certificationDataType has invalid value: ${qeCertificationDataType}`);
+        }
+        const certificationDataSize = rawQuoteSignatureDataRemainder.data.readUInt32LE(2);
+        const qeCertificationData = rawQuoteSignatureDataRemainder.data.subarray(2 + 4);
+        if (certificationDataSize != qeCertificationData.length) {
+            throw new TeeQuoteParserError(`certificationDataSize has invalid length: $PqeCertificationData.length} instead of ${certificationDataSize} expected`);
+        }
+        const certsPems = splitChain(qeCertificationData.toString()); // [device, platform, root]
+        const certsData = certsPems.map((pem) => this.parsePem(pem));
+        return {
+            rawHeader: quoteHeader,
+            header: {
+                version,
+                attestationKeyType,
+                pceSvn,
+                userData,
+            },
+            report,
+            isvEnclaveReportSignature,
+            ecdsaAttestationKey,
+            qeReport,
+            qeReportSignature,
+            qeAuthenticationData,
+            qeCertificationDataType,
+            qeCertificationData,
+            certificates: {
+                device: {
+                    pem: certsPems[0],
+                    x509Data: certsData[0],
+                },
+                platform: {
+                    pem: certsPems[1],
+                    x509Data: certsData[1],
+                },
+                root: {
+                    pem: certsPems[2],
+                    x509Data: certsData[2],
+                },
+            },
+        };
+    }
+    parseReport(data) {
+        const { reportSize, cpuSvnSize, reportMrEnclaveOffset, reportMrEnclaveSize, reportMrSignerOffset, reportMrSignerSize, reportIsvProdIdOffset, reportIsvProdIdSize, reportIsvSvnOffset, reportIsvSvnSize, reportDataOffset, reportUserDataSize, reportUserDataSHA256Size, } = TeeSgxParser;
+        if (data.length < reportSize) {
+            throw new TeeQuoteParserError('data has invalid length');
+        }
+        const report = Blob.from(data);
+        const cpuSvn = report.slice(0, cpuSvnSize).toString('hex');
+        const mrEnclave = report.slice(reportMrEnclaveOffset, reportMrEnclaveOffset + reportMrEnclaveSize);
+        const mrSigner = report.slice(reportMrSignerOffset, reportMrSignerOffset + reportMrSignerSize);
+        const isvProdId = report
+            .slice(reportIsvProdIdOffset, reportIsvProdIdOffset + reportIsvProdIdSize)
+            .readUInt16LE(0);
+        const isvSvn = report
+            .slice(reportIsvSvnOffset, reportIsvSvnOffset + reportIsvSvnSize)
+            .readUInt16LE(0);
+        const userData = report.slice(reportDataOffset, reportDataOffset + reportUserDataSize);
+        const dataHash = report.slice(reportDataOffset, reportDataOffset + reportUserDataSHA256Size);
+        return {
+            cpuSvn,
+            mrEnclave,
+            mrSigner,
+            isvProdId,
+            isvSvn,
+            userData,
+            dataHash,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QuoteParser.js","sourceRoot":"","sources":["../../../src/tee/QuoteParser.ts"],"names":[],"mappings":"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"}

package/dist/mjs/tee/QuoteValidator.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { QuoteValidationStatuses } from './statuses.js';
+export interface ValidationResult {
+    quoteValidationStatus: QuoteValidationStatuses;
+    description: string;
+    error?: unknown;
+}
+export declare class QuoteValidator {
+    private readonly isDefault;
+    private readonly baseUrl;
+    private readonly teeSgxParser;
+    private logger;
+    constructor(baseUrl: string);
+    private splitChain;
+    private findSequenceByOID;
+    private searchForSequence;
+    private verifyDataBySignature;
+    private checkValidDate;
+    private checkChainForIssuers;
+    private getCrl;
+    private checkCertificatesInCrl;
+    private getCertificates;
+    private verifyQeReportSignature;
+    private verifyQeReportData;
+    private verifyEnclaveReportSignature;
+    private validateQuoteStructure;
+    private getSgxExtensionData;
+    private getDataFromExtension;
+    private getTcbInfo;
+    private getQEIdentity;
+    private getQEIdentityStatus;
+    private getTcbStatus;
+    private getQuoteValidationStatus;
+    private getQuoteValidationStatusDescription;
+    validate(quoteBuffer: Buffer): Promise<ValidationResult>;
+    isQuoteHasUserData(quoteBuffer: Buffer, userDataBuffer: Buffer): Promise<boolean>;
+    private getSha256Hash;
+}