@super-protocol/swarm-contracts-sdk 0.0.1-beta.1

package/dist/mjs/staticModels/SuperproToken.js

@@ -0,0 +1,328 @@
+import PQueue from 'p-queue';
+import rootLogger from '../logger.js';
+import store from '../store.js';
+import { checkIfActionAccountInitialized, convertBigIntToString, makeOnData, withCleanArgs, } from '../utils/helper.js';
+import TxManager from '../utils/TxManager.js';
+import { BlockchainEventsListener } from '../connectors/index.js';
+import { SuperProtocolToken__factory } from '../contracts/SuperProtocolToken__factory.js';
+class SuperproToken {
+    static _addressHttps;
+    static _addressWss;
+    static contractHttps;
+    static logger = rootLogger.child({ className: 'SuperproToken' });
+    static get addressHttps() {
+        return SuperproToken._addressHttps;
+    }
+    static set addressHttps(newAddress) {
+        SuperproToken._addressHttps = newAddress;
+        SuperproToken.contractHttps = SuperproToken.createContract(newAddress);
+    }
+    static createContract(newAddress) {
+        return SuperProtocolToken__factory.connect(newAddress, store.httpsProvider);
+    }
+    static get addressWss() {
+        return SuperproToken._addressWss;
+    }
+    static set addressWss(newAddress) {
+        SuperproToken._addressWss = newAddress;
+    }
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    static checkInit() {
+        if (!SuperproToken.contractHttps) {
+            throw Error(`SuperproToken must be initialized before it can be used`);
+        }
+        return SuperproToken.contractHttps;
+    }
+    /**
+     * Retrieves past "Transfer" events emitted by the token contract,
+     * optionally filtered by `from` and/or `to` addresses and a block range.
+     *
+     * Enriches each event with the block timestamp (`blockTimestamp`)
+     * by fetching the block using a concurrency-limited queue.
+     */
+    static async getTransferEvents(params, options) {
+        const { filter, fromBlock, toBlock } = params;
+        const { concurrency = 10, contract } = options ?? {};
+        const contractInstance = await this.getContract(contract);
+        const eventFilter = contractInstance.filters.Transfer(filter?.from, filter?.to);
+        const events = await contractInstance.queryFilter(eventFilter, fromBlock, toBlock);
+        const queue = new PQueue({ concurrency });
+        const blockTimestamps = new Map();
+        return Promise.all(events.map(async (event) => {
+            const blockNumber = BigInt(event.blockNumber);
+            let timestampPromise = blockTimestamps.get(blockNumber);
+            if (!timestampPromise) {
+                timestampPromise = queue.add(async () => {
+                    const block = await contractInstance.runner.provider.getBlock(blockNumber);
+                    if (!block) {
+                        throw new Error(`Block ${blockNumber.toString()} not found`);
+                    }
+                    return Number(block.timestamp);
+                });
+                blockTimestamps.set(blockNumber, timestampPromise);
+            }
+            const timestamp = await timestampPromise;
+            return {
+                from: event.args.from,
+                to: event.args.to,
+                value: event.args.value,
+                transactionHash: event.transactionHash,
+                blockNumber,
+                blockTimestamp: timestamp,
+            };
+        }));
+    }
+    /**
+     * Fetching balance of SuperProtocol tokens on address
+     */
+    static async balanceOf(address, contract) {
+        return convertBigIntToString(await this.getContract(contract).balanceOf(address));
+    }
+    /**
+     * Fetching allowance of SuperProtocol tokens on address
+     */
+    static async allowance(from, to, contract) {
+        return convertBigIntToString(await this.getContract(contract).allowance(from, to));
+    }
+    /**
+     * Fetching symbol of SuperProtocol tokens
+     */
+    static symbol(contract) {
+        return this.getContract(contract).symbol();
+    }
+    /**
+     * Fetching true if the address is whitelisted
+     */
+    static async isWhitelisted(address) {
+        this.checkInit();
+        return await this.contractHttps.whitelist(address);
+    }
+    /**
+     * Fetching true if the whitelist is activated
+     */
+    static async isWhitelistActivated() {
+        this.checkInit();
+        return convertBigIntToString(await this.contractHttps.whitelistIsActivated());
+    }
+    /**
+     * Transfers specific amount of SP tokens to specific address
+     * @param to - address to revive tokens
+     * @param amount - amount of tokens to transfer
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async transfer(to, amount, transactionOptions) {
+        const contract = this.checkInit();
+        checkIfActionAccountInitialized(transactionOptions);
+        const transaction = await contract.transfer.populateTransaction(to, amount);
+        return await TxManager.execute(transaction, transactionOptions);
+    }
+    /**
+     * Approve tokens for specific address
+     * @param address - address for approval
+     * @param amount - number of tokens to be approved
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async approve(address, amount, transactionOptions, contractInstance) {
+        const contract = this.getContract(contractInstance);
+        checkIfActionAccountInitialized(transactionOptions);
+        const transaction = await contract.approve.populateTransaction(address, amount);
+        return await TxManager.execute(transaction, transactionOptions);
+    }
+    /**
+     * Adds an address to the whitelist.
+     * @param address - address
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async addWhitelistAddress(address, transactionOptions) {
+        const contract = this.checkInit();
+        checkIfActionAccountInitialized(transactionOptions);
+        const transaction = await contract.addWhitelistAddress.populateTransaction(address);
+        await TxManager.execute(transaction, transactionOptions);
+    }
+    /**
+     * Removes an address from the whitelist.
+     * @param address - address
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async removeWhitelistAddress(address, transactionOptions) {
+        const contract = this.checkInit();
+        checkIfActionAccountInitialized(transactionOptions);
+        const transaction = await contract.removeWhitelistAddress.populateTransaction(address);
+        await TxManager.execute(transaction, transactionOptions);
+    }
+    /**
+     * Activates the whitelist.
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async activateWhitelist(transactionOptions) {
+        const contract = this.checkInit();
+        checkIfActionAccountInitialized(transactionOptions);
+        const transaction = await contract.activateWhitelist.populateTransaction();
+        await TxManager.execute(transaction, transactionOptions);
+    }
+    /**
+     * Deactivates the whitelist.
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static async deactivateWhitelist(transactionOptions) {
+        const contract = this.checkInit();
+        checkIfActionAccountInitialized(transactionOptions);
+        const transaction = await contract.deactivateWhitelist.populateTransaction();
+        await TxManager.execute(transaction, transactionOptions);
+    }
+    static onTokenApprove(callback, owner, spender) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getTokenContract();
+        const eventName = 'Approval';
+        const logger = this.logger.child({ method: 'onTokenApprove' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (owner && eventArgs.owner.toLowerCase() !== owner.toLowerCase()) {
+                return;
+            }
+            if (spender && eventArgs.spender.toLowerCase() !== spender.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.owner, eventArgs.spender, eventArgs.value, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+            contract,
+        });
+    }
+    static onTokenTransfer(callback, from, to) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getTokenContract();
+        const eventName = 'Transfer';
+        const logger = this.logger.child({ method: 'onTokenTransfer' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (from && eventArgs.from.toLowerCase() !== from.toLowerCase()) {
+                return;
+            }
+            if (to && eventArgs.to.toLowerCase() !== to.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.from, eventArgs.to, eventArgs.value, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+            contract,
+        });
+    }
+    static onAddressAddedToWhitelist(callback, address) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getTokenContract();
+        const eventName = 'AddressAddedToWhitelist';
+        const logger = this.logger.child({ method: 'onAddressAddedToWhitelist' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (address && eventArgs.arg0.toLowerCase() !== address.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.arg0, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+            contract,
+        });
+    }
+    static onAddressRemovedFromWhitelist(callback, address) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getTokenContract();
+        const eventName = 'AddressRemovedFromWhitelist';
+        const logger = this.logger.child({ method: 'onAddressRemovedFromWhitelist' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            const eventArgs = eventLog.args;
+            if (address && eventArgs.arg0.toLowerCase() !== address.toLowerCase()) {
+                return;
+            }
+            withCleanArgs(callback)(eventArgs.arg0, {
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+            contract,
+        });
+    }
+    static onWhitelistActivated(callback) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getTokenContract();
+        const eventName = 'WhitelistActivated';
+        const logger = this.logger.child({ method: 'onWhitelistActivated' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            withCleanArgs(callback)({
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+            contract,
+        });
+    }
+    static onWhitelistDeactivated(callback) {
+        const listener = BlockchainEventsListener.getInstance();
+        const contract = listener.getTokenContract();
+        const eventName = 'WhitelistDeactivated';
+        const logger = this.logger.child({ method: 'onWhitelistDeactivated' });
+        const onData = makeOnData(contract, eventName, (eventLog) => {
+            withCleanArgs(callback)({
+                index: eventLog.blockNumber,
+                hash: eventLog.blockHash,
+            });
+        });
+        const onError = (error) => {
+            logger.warn(error);
+        };
+        return listener.subscribeEvent({
+            onError,
+            onData,
+            event: eventName,
+            contract,
+        });
+    }
+    static getContract(contract) {
+        return contract ? contract : SuperproToken.checkInit();
+    }
+}
+export default SuperproToken;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SuperproToken.js","sourceRoot":"","sources":["../../../src/staticModels/SuperproToken.ts"],"names":[],"mappings":"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"}

package/dist/mjs/store.d.ts

@@ -0,0 +1,17 @@
+import { JsonRpcProvider, WebSocketProvider } from 'ethers';
+export type Store = {
+    wssProvider?: WebSocketProvider;
+    httpsProvider?: JsonRpcProvider;
+    actionAccount?: string;
+    gasLimit: bigint;
+    gasLimitMultiplier: number;
+    gasPrice?: bigint;
+    txConcurrency: number;
+    txIntervalMs: number;
+    chainId: number;
+    maxFeePerGasMultiplier: number;
+    maxPriorityFeePerGasMultiplier: number;
+    keys: Record<string, string>;
+};
+declare const store: Store;
+export default store;

package/dist/mjs/store.js

@@ -0,0 +1,17 @@
+import { defaultGasLimitMultiplier, defaultGasLimit, defaultMaxFeePerGasMultiplier, defaultMaxPriorityFeePerGasMultiplier, txIntervalMs, txConcurrency, POLYGON_MAIN_CHAIN_ID, } from './constants.js';
+const store = {
+    wssProvider: undefined,
+    httpsProvider: undefined,
+    actionAccount: undefined,
+    gasLimit: defaultGasLimit,
+    gasLimitMultiplier: defaultGasLimitMultiplier,
+    gasPrice: undefined,
+    txConcurrency: txConcurrency,
+    txIntervalMs: txIntervalMs,
+    chainId: POLYGON_MAIN_CHAIN_ID,
+    maxFeePerGasMultiplier: defaultMaxFeePerGasMultiplier,
+    maxPriorityFeePerGasMultiplier: defaultMaxPriorityFeePerGasMultiplier,
+    keys: {},
+};
+export default store;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLHlCQUF5QixFQUN6QixlQUFlLEVBQ2YsNkJBQTZCLEVBQzdCLHFDQUFxQyxFQUNyQyxZQUFZLEVBQ1osYUFBYSxFQUNiLHFCQUFxQixHQUN0QixNQUFNLGdCQUFnQixDQUFDO0FBaUJ4QixNQUFNLEtBQUssR0FBVTtJQUNuQixXQUFXLEVBQUUsU0FBUztJQUN0QixhQUFhLEVBQUUsU0FBUztJQUN4QixhQUFhLEVBQUUsU0FBUztJQUN4QixRQUFRLEVBQUUsZUFBZTtJQUN6QixrQkFBa0IsRUFBRSx5QkFBeUI7SUFDN0MsUUFBUSxFQUFFLFNBQVM7SUFDbkIsYUFBYSxFQUFFLGFBQWE7SUFDNUIsWUFBWSxFQUFFLFlBQVk7SUFDMUIsT0FBTyxFQUFFLHFCQUFxQjtJQUM5QixzQkFBc0IsRUFBRSw2QkFBNkI7SUFDckQsOEJBQThCLEVBQUUscUNBQXFDO0lBQ3JFLElBQUksRUFBRSxFQUFFO0NBQ1QsQ0FBQztBQUVGLGVBQWUsS0FBSyxDQUFDIn0=

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { OrderReport } from '@super-protocol/dto-js';
+export declare class OrderReportService {
+    static encode(orderReport: OrderReport): Promise<Buffer>;
+    static decode(encodedOrderReport: Buffer): Promise<OrderReport>;
+    static validateOrderReport(orderReport: OrderReport): Promise<void>;
+    private static hashToBinary;
+    private static binaryHashToHash;
+}

package/dist/mjs/tee/OrderReportService.js

@@ -0,0 +1,97 @@
+import { promisify } from 'util';
+import zlib from 'zlib';
+import { Encoding, } from '@super-protocol/dto-js';
+import { OrderReportProto } from '../proto/OrderReport.js';
+import { OID_CUSTOM_EXTENSION_ORDER_REPORT_WORKLOAD_INFO_HASH } from '../constants.js';
+import { calculateObjectHash } from '../utils/helpers/calculateObjectHash.js';
+import { CertificatesHelper } from '../certificates/helper.js';
+import { TeeCertificateService } from './TeeCertificateService.js';
+const gzipPromise = promisify(zlib.gzip);
+const unzipPromise = promisify(zlib.unzip);
+export class OrderReportService {
+    static async encode(orderReport) {
+        const { certs } = CertificatesHelper.extractCAFromChain(orderReport.certificate);
+        const certsDer = CertificatesHelper.pemChainToDer(certs);
+        const orderReportProto = {
+            certificates: certsDer,
+            workloadInfo: {
+                runtimeInfo: orderReport.workloadInfo.runtimeInfo.map((ri) => ({
+                    type: ri.type,
+                    size: ri.size,
+                    hash: this.hashToBinary(ri.hash),
+                    signatureKeyHash: this.hashToBinary(ri.signatureKeyHash),
+                    argsHash: this.hashToBinary(ri.argsHash),
+                })),
+                created: orderReport.workloadInfo.created,
+                orderCapacity: orderReport.workloadInfo.orderCapacity,
+            },
+        };
+        const encoded = OrderReportProto.encode(orderReportProto).finish();
+        const compressed = await gzipPromise(encoded, { level: 9 });
+        return compressed;
+    }
+    static async decode(encodedOrderReport) {
+        const decompressed = await unzipPromise(encodedOrderReport);
+        const orderReportProto = OrderReportProto.decode(decompressed);
+        const certsPem = CertificatesHelper.derChainToPem(orderReportProto.certificates);
+        if (!orderReportProto.workloadInfo) {
+            throw new Error(`Wrong order report! Missing workloadInfo`);
+        }
+        const runtimeInfo = orderReportProto.workloadInfo.runtimeInfo.map((riProto) => {
+            const result = {
+                type: riProto.type,
+                size: riProto.size,
+                hash: this.binaryHashToHash(riProto.hash),
+            };
+            if (riProto.signatureKeyHash) {
+                result.signatureKeyHash = this.binaryHashToHash(riProto.signatureKeyHash);
+            }
+            if (riProto.argsHash) {
+                result.argsHash = this.binaryHashToHash(riProto.argsHash);
+            }
+            return result;
+        });
+        return {
+            certificate: certsPem,
+            workloadInfo: {
+                runtimeInfo,
+                created: orderReportProto.workloadInfo.created,
+                ...(orderReportProto.workloadInfo.orderCapacity && {
+                    orderCapacity: orderReportProto.workloadInfo.orderCapacity,
+                }),
+            },
+        };
+    }
+    static async validateOrderReport(orderReport) {
+        await TeeCertificateService.validateTeeCertChainOrFail(orderReport.certificate);
+        const workloadInfoHashFromCert = CertificatesHelper.getExtensionValue(orderReport.certificate, OID_CUSTOM_EXTENSION_ORDER_REPORT_WORKLOAD_INFO_HASH);
+        if (!workloadInfoHashFromCert) {
+            throw new Error(`WorkloadInfoHash is missing in certificate!`);
+        }
+        const workloadInfoHash = calculateObjectHash(orderReport.workloadInfo);
+        const isHashMatch = Buffer.compare(workloadInfoHashFromCert, Buffer.from(workloadInfoHash.hash, workloadInfoHash.encoding)) === 0;
+        if (!isHashMatch) {
+            throw new Error(`WorkloadInfoHash in the certificate doesn't match the WorkloadInfoHash in the orderReport`);
+        }
+    }
+    static hashToBinary(hash) {
+        if (!hash) {
+            return;
+        }
+        return {
+            algo: hash.algo,
+            hash: Buffer.from(hash.hash, hash.encoding),
+        };
+    }
+    static binaryHashToHash(binaryHash) {
+        if (!binaryHash) {
+            return;
+        }
+        return {
+            algo: binaryHash.algo,
+            hash: Buffer.from(binaryHash.hash).toString(Encoding.hex),
+            encoding: Encoding.hex,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,82 @@
+/// <reference types="node" />
+import * as pkijs from 'pkijs';
+import { Buffer as Blob } from 'buffer';
+import { BinaryType, TeeSgxQuoteDataType, TeeSgxReportDataType, ChunkedX509Cert, TeeTdxQuoteDataType, TeeTdxBodyType, TeeTdxHeaderData, QuoteType } from './types.js';
+export declare abstract class TeeParser {
+    static readonly reportDataHashSize = 32;
+    protected extractRS(cert: pkijs.Certificate): {
+        r: string;
+        s: string;
+        derSignature: string;
+    };
+    protected parsePem(pem: string): ChunkedX509Cert;
+    protected getDataAndAdvance(blob: {
+        data: Blob;
+    }, size: number): Blob;
+    static determineQuoteType(quote: BinaryType): {
+        type: QuoteType;
+        version: number;
+    };
+    static getMrEnclave(quote: BinaryType): BinaryType;
+}
+export declare class TeeSgxParser extends TeeParser {
+    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 ecdsaP256SignatureSize = 64;
+    static readonly ecdsaP256PublicKeySize = 64;
+    parseQuote(data: BinaryType): TeeSgxQuoteDataType;
+    parseReport(data: BinaryType): TeeSgxReportDataType;
+}
+export declare class TeeTdxParser extends TeeParser {
+    static readonly quoteHeaderSize = 48;
+    static readonly tdQuoteBodySize = 584;
+    static readonly quoteSignatureDataLen = 4;
+    static readonly headerVersionSize = 2;
+    static readonly headerAttestationKeyTypeSize = 2;
+    static readonly headerTeeTypeSize = 4;
+    static readonly headerReserved1Size = 2;
+    static readonly headerReserved2Size = 2;
+    static readonly headerQeVendorIdSize = 16;
+    static readonly headerUserDataSize = 20;
+    static readonly bodyTeeTcbSvnSize = 16;
+    static readonly bodyMrSeamSize = 48;
+    static readonly bodyMrSignerSeamSize = 48;
+    static readonly bodySeamAttributesSize = 8;
+    static readonly bodyTdAttributesSize = 8;
+    static readonly bodyXfamSize = 8;
+    static readonly bodyMrTdSize = 48;
+    static readonly bodyMrConfigIdSize = 48;
+    static readonly bodyMrOwnerSize = 48;
+    static readonly bodyMrOwnerConfigSize = 48;
+    static readonly bodyRtmr0Size = 48;
+    static readonly bodyRtmr1Size = 48;
+    static readonly bodyRtmr2Size = 48;
+    static readonly bodyRtmr3Size = 48;
+    static readonly bodyReportDataSize = 64;
+    static readonly sigQuoteSignatureSize = 64;
+    static readonly sigAttestationKeySize = 64;
+    static readonly sigCertDataTypeSize = 2;
+    static readonly sigCertDataSzSize = 4;
+    static readonly sigQeReportSize = 384;
+    static readonly sigQeReportSignatureSize = 64;
+    static readonly sigQeAuthenticationDataSzSize = 2;
+    static readonly sigSignatureTypeSize = 2;
+    static readonly sigSignatureSzSize = 4;
+    parseQuote(data: BinaryType): TeeTdxQuoteDataType;
+    parseHeader(data: BinaryType): TeeTdxHeaderData;
+    parseBody(data: BinaryType): TeeTdxBodyType;
+}