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

package/dist/mjs/connectors/BaseConnector.d.ts

@@ -0,0 +1,52 @@
+import { SuperProtocolToken } from '../contracts/SuperProtocolToken.js';
+import { App } from '../contracts/typechain-types/index.js';
+export interface ReconnectOptions {
+    autoReconnect?: boolean;
+    delay?: number;
+    maxAttempts?: number;
+}
+export type Config = {
+    contractAddress: string;
+    blockchainUrl?: string;
+    gasPrice?: bigint;
+    gasLimit?: bigint;
+    gasLimitMultiplier?: number;
+    txConcurrency?: number;
+    txIntervalMs?: number;
+    reconnect?: Partial<ReconnectOptions>;
+    externalTransactionSigner?: boolean;
+};
+export declare class BaseConnector {
+    protected initialized: boolean;
+    protected logger: import("pino").default.Logger<{
+        level: string;
+        enabled: boolean;
+    } & import("pino").default.ChildLoggerOptions>;
+    protected contract?: App;
+    protected tokenContract?: SuperProtocolToken;
+    protected tokenAddress?: string;
+    isInitialized(): boolean;
+    checkIfInitialized(): void;
+    /**
+     *
+     * @returns initialized contract
+     */
+    getContract(): App;
+    /**
+     *
+     * @returns initialized contract
+     */
+    getTokenContract(): SuperProtocolToken;
+    /**
+     *
+     * @returns default token address
+     */
+    getTokenAddress(): string;
+    /**
+     * Function for connecting to blockchain
+     * Used to setting up settings for blockchain connector
+     * Needs to run this function before using blockchain connector
+     */
+    initialize(_config: Config): Promise<void>;
+    shutdown(): void;
+}

package/dist/mjs/connectors/BaseConnector.js

@@ -0,0 +1,54 @@
+import rootLogger from '../logger.js';
+export class BaseConnector {
+    initialized = false;
+    logger = rootLogger.child({ className: this.constructor['name'] });
+    contract;
+    tokenContract;
+    tokenAddress;
+    isInitialized() {
+        return this.initialized;
+    }
+    checkIfInitialized() {
+        if (!this.initialized)
+            throw new Error(`${this.constructor['name']} is not initialized, needs to run '${this.constructor['name']}.initialize(CONFIG)' first`);
+    }
+    /**
+     *
+     * @returns initialized contract
+     */
+    getContract() {
+        this.checkIfInitialized();
+        return this.contract;
+    }
+    /**
+     *
+     * @returns initialized contract
+     */
+    getTokenContract() {
+        this.checkIfInitialized();
+        return this.tokenContract;
+    }
+    /**
+     *
+     * @returns default token address
+     */
+    getTokenAddress() {
+        this.checkIfInitialized();
+        return this.tokenAddress;
+    }
+    /**
+     * Function for connecting to blockchain
+     * Used to setting up settings for blockchain connector
+     * Needs to run this function before using blockchain connector
+     */
+    initialize(_config) {
+        return Promise.resolve();
+    }
+    shutdown() {
+        if (this.initialized) {
+            this.initialized = false;
+            this.logger.trace(`${this.constructor['name']} was shutdown`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFzZUNvbm5lY3Rvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25uZWN0b3JzL0Jhc2VDb25uZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxVQUFVLE1BQU0sY0FBYyxDQUFDO0FBb0J0QyxNQUFNLE9BQU8sYUFBYTtJQUNkLFdBQVcsR0FBRyxLQUFLLENBQUM7SUFDcEIsTUFBTSxHQUFHLFVBQVUsQ0FBQyxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQUUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDbkUsUUFBUSxDQUFPO0lBQ2YsYUFBYSxDQUFzQjtJQUNuQyxZQUFZLENBQVU7SUFFekIsYUFBYTtRQUNsQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDMUIsQ0FBQztJQUVNLGtCQUFrQjtRQUN2QixJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVc7WUFDbkIsTUFBTSxJQUFJLEtBQUssQ0FDYixHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLHNDQUFzQyxJQUFJLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyw0QkFBNEIsQ0FDdEgsQ0FBQztJQUNOLENBQUM7SUFFRDs7O09BR0c7SUFDSSxXQUFXO1FBQ2hCLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1FBRTFCLE9BQU8sSUFBSSxDQUFDLFFBQVMsQ0FBQztJQUN4QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksZ0JBQWdCO1FBQ3JCLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1FBRTFCLE9BQU8sSUFBSSxDQUFDLGFBQWMsQ0FBQztJQUM3QixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksZUFBZTtRQUNwQixJQUFJLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztRQUUxQixPQUFPLElBQUksQ0FBQyxZQUFhLENBQUM7SUFDNUIsQ0FBQztJQUNEOzs7O09BSUc7SUFDSSxVQUFVLENBQUMsT0FBZTtRQUMvQixPQUFPLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRU0sUUFBUTtRQUNiLElBQUksSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ3JCLElBQUksQ0FBQyxXQUFXLEdBQUcsS0FBSyxDQUFDO1lBQ3pCLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsZUFBZSxDQUFDLENBQUM7UUFDaEUsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

package/dist/mjs/connectors/BlockchainConnector.d.ts

@@ -0,0 +1,78 @@
+import { BaseConnector, Config } from './BaseConnector.js';
+import { TransactionOptions, EventData, BlockInfo, TokenAmount } from '../types/Web3.js';
+import BlockchainTransaction from '../types/blockchainConnector/StorageAccess.js';
+import { TransactionReceipt } from 'ethers';
+declare class BlockchainConnector extends BaseConnector {
+    private defaultActionAccount?;
+    private static instance;
+    private constructor();
+    static getInstance(): BlockchainConnector;
+    /**
+     * Function for connecting to blockchain
+     * Used to setting up settings for blockchain connector
+     * Needs to run this function before using blockchain connector
+     */
+    initialize(config: Config): Promise<void>;
+    /**
+     * Function for connecting provider action account
+     * Needs to run this function before using any set methods in blockchain connector
+     */
+    initializeActionAccount(actionAccountKey: string, manageNonce?: boolean): Promise<string>;
+    /**
+     * Returns balance of blockchain platform tokens in wei
+     */
+    getBalance(address: string): Promise<string>;
+    getTimestamp(): Promise<bigint>;
+    /**
+     * Returns transactions events info
+     * @param txHash - transaction hash
+     * @returns `Promise<EventData[]>` - Transaction events info
+     */
+    getTransactionEvents(txHash: string): Promise<EventData[]>;
+    /**
+     * 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
+     */
+    getLastBlockInfo(): Promise<BlockInfo>;
+    /**
+     * Function that searches (using binary search) first block data that node has
+     * @param startIndex - start block that function needs to start search with
+     * @returns block number
+     */
+    searchFirstBlockInTheNode(startIndex?: number): Promise<number>;
+    /**
+     * Returns transactions reciept
+     * @param txHash - transaction hash
+     * @returns `Promise<TransactionReceipt | null>` - Transaction reciept
+     */
+    getTransactionReceipt(txHash: string): Promise<TransactionReceipt | null>;
+    /**
+     * Returns balance of blockchain platform tokens in wei
+     */
+    transfer(to: string, amount: TokenAmount, transactionOptions?: TransactionOptions): Promise<TransactionReceipt>;
+    /**
+     * Returns transactions count
+     * @param address - wallet address
+     * @returns Promise<number> - Transactions count
+     */
+    getTransactionCount(address: string, status?: string): Promise<number>;
+    getAddressByKey(pk: string): string;
+    /**
+     * Fetch transactions for specific addresses starting with specific block until last block
+     * @param addresses - array of addresses IN LOWER CASE to fetch transactions (from these addresses and to these addresses)
+     * @param startBlock - number of block to start fetching transactions (if empty fetch only for last block)
+     * @param lastBlock - number of block to last fetching transactions (if empty fetch only for last block)
+     * @param batchSize - block size for asynchronous transaction loading
+     * @returns Promise<BlockchainTransaction> with found transactions and last fetched block
+     */
+    getTransactions({ addresses, startBlock, lastBlock, batchSize, timeout, }: {
+        addresses: string[];
+        startBlock?: number;
+        lastBlock?: number;
+        batchSize?: number;
+        timeout?: number;
+    }): Promise<BlockchainTransaction>;
+    shutdown(): void;
+}
+export default BlockchainConnector;

package/dist/mjs/connectors/BlockchainConnector.js

@@ -0,0 +1,320 @@
+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 { BaseConnector } from './BaseConnector.js';
+import { BLOCK_SIZE_TO_FETCH_TRANSACTION, POLYGON_MATIC_EVENT_PATH, defaultBlockchainUrl, defaultGasPrice, } from '../constants.js';
+import { checkIfActionAccountInitialized, cleanWeb3Data, incrementMethodCall, executeBatchAsync, preparePrivateKey, } from '../utils/helper.js';
+import TxManager from '../utils/TxManager.js';
+import { Wallet, JsonRpcProvider, isAddress, } from 'ethers';
+// TODO: remove this dependencies
+import store from '../store.js';
+import Superpro from '../staticModels/Superpro.js';
+import SuperproToken from '../staticModels/SuperproToken.js';
+import { Monitoring } from '../utils/Monitoring.js';
+import { SuperProtocolToken__factory } from '../contracts/SuperProtocolToken__factory.js';
+import { App__factory } from '../contracts/typechain-types/index.js';
+class BlockchainConnector extends BaseConnector {
+    defaultActionAccount;
+    // Singleton
+    static instance;
+    constructor() {
+        super();
+    }
+    static getInstance() {
+        if (!BlockchainConnector.instance) {
+            BlockchainConnector.instance = new BlockchainConnector();
+        }
+        return BlockchainConnector.instance;
+    }
+    /**
+     * Function for connecting to blockchain
+     * Used to setting up settings for blockchain connector
+     * Needs to run this function before using blockchain connector
+     */
+    async initialize(config) {
+        this.logger.trace(config, 'Initializing');
+        const url = config?.blockchainUrl || defaultBlockchainUrl;
+        store.httpsProvider = new JsonRpcProvider(url);
+        store.chainId = Number((await store.httpsProvider.getNetwork()).chainId);
+        store.gasPrice = config?.gasPrice ?? defaultGasPrice;
+        if (config?.gasLimit)
+            store.gasLimit = config.gasLimit;
+        if (config?.gasLimitMultiplier)
+            store.gasLimitMultiplier = config.gasLimitMultiplier;
+        if (config?.txConcurrency)
+            store.txConcurrency = config.txConcurrency;
+        if (config?.txIntervalMs)
+            store.txIntervalMs = config.txIntervalMs;
+        Superpro.address = config.contractAddress;
+        this.contract = App__factory.connect(Superpro.address, store.httpsProvider);
+        TxManager.init(store.httpsProvider, config.externalTransactionSigner);
+        const tokenAddress = await Superpro.getPrimaryTokenAddress(this.contract);
+        SuperproToken.addressHttps = tokenAddress;
+        this.tokenAddress = tokenAddress;
+        this.tokenContract = SuperProtocolToken__factory.connect(tokenAddress, store.httpsProvider);
+        Monitoring.getInstance().initializeLogging();
+        this.initialized = true;
+        this.logger.trace('Initialized');
+    }
+    /**
+     * Function for connecting provider action account
+     * Needs to run this function before using any set methods in blockchain connector
+     */
+    async initializeActionAccount(actionAccountKey, manageNonce = true) {
+        this.checkIfInitialized();
+        const preparedActionAccountKey = preparePrivateKey(actionAccountKey);
+        const actionAccount = new Wallet(preparedActionAccountKey).address;
+        if (!store.actionAccount)
+            store.actionAccount = actionAccount;
+        if (!store.keys[actionAccount])
+            store.keys[actionAccount] = preparedActionAccountKey;
+        if (!this.defaultActionAccount)
+            this.defaultActionAccount = actionAccount;
+        if (manageNonce) {
+            await TxManager.initAccount(actionAccount);
+        }
+        return actionAccount;
+    }
+    /**
+     * Returns balance of blockchain platform tokens in wei
+     */
+    getBalance(address) {
+        this.checkIfInitialized();
+        return store.httpsProvider.getBalance(address).then((balance) => balance.toString());
+    }
+    async getTimestamp() {
+        this.checkIfInitialized();
+        const block = await store.httpsProvider.getBlock('latest');
+        if (!block)
+            throw new Error('Latest block not found');
+        return BigInt(block.timestamp);
+    }
+    /**
+     * Returns transactions events info
+     * @param txHash - transaction hash
+     * @returns `Promise<EventData[]>` - Transaction events info
+     */
+    async getTransactionEvents(txHash) {
+        this.checkIfInitialized();
+        const receipt = await store.httpsProvider.getTransactionReceipt(txHash);
+        if (!receipt)
+            throw new Error(`Transaction ${txHash} not found`);
+        const eventData = [];
+        const diamondInterface = BlockchainConnector.getInstance().getContract().interface;
+        const tokenInterface = BlockchainConnector.getInstance().getTokenContract().interface;
+        for (const log of receipt.logs) {
+            if (!log.address || log.address === POLYGON_MATIC_EVENT_PATH) {
+                continue;
+            }
+            try {
+                let parsedLog = diamondInterface.parseLog(log);
+                if (!parsedLog) {
+                    parsedLog = tokenInterface.parseLog(log);
+                }
+                if (parsedLog) {
+                    eventData.push({
+                        contract: log.address,
+                        name: parsedLog.name || 'UnknownEvent',
+                        data: cleanWeb3Data(parsedLog),
+                    });
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return eventData;
+    }
+    /**
+     * 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
+     */
+    async getLastBlockInfo() {
+        this.checkIfInitialized();
+        const index = Number(await store.httpsProvider.getBlockNumber());
+        const hash = (await store.httpsProvider.getBlock(index)).hash;
+        return {
+            index,
+            hash,
+        };
+    }
+    /**
+     * Function that searches (using binary search) first block data that node has
+     * @param startIndex - start block that function needs to start search with
+     * @returns block number
+     */
+    async searchFirstBlockInTheNode(startIndex = 0) {
+        this.checkIfInitialized();
+        let latestBlockIndex = Number(await store.httpsProvider.getBlockNumber());
+        while (startIndex <= latestBlockIndex) {
+            const mid = Math.floor((startIndex + latestBlockIndex) / 2);
+            const txReceipt = await store
+                .httpsProvider.getBlock(mid)
+                .then((block) => {
+                if (block === null)
+                    return null;
+                return store.httpsProvider.getTransactionReceipt(block.transactions[0]);
+            })
+                .catch(/*suppress error*/ () => undefined);
+            if (txReceipt) {
+                latestBlockIndex = mid - 1;
+            }
+            else {
+                startIndex = mid + 1;
+            }
+        }
+        return latestBlockIndex + 1;
+    }
+    /**
+     * Returns transactions reciept
+     * @param txHash - transaction hash
+     * @returns `Promise<TransactionReceipt | null>` - Transaction reciept
+     */
+    getTransactionReceipt(txHash) {
+        this.checkIfInitialized();
+        return store.httpsProvider.getTransactionReceipt(txHash);
+    }
+    /**
+     * Returns balance of blockchain platform tokens in wei
+     */
+    transfer(to, amount, transactionOptions) {
+        this.checkIfInitialized();
+        checkIfActionAccountInitialized(transactionOptions);
+        const transaction = {
+            to,
+            value: BigInt(amount),
+            data: '0x',
+        };
+        return TxManager.publishTransaction(transaction, transactionOptions);
+    }
+    /**
+     * Returns transactions count
+     * @param address - wallet address
+     * @returns Promise<number> - Transactions count
+     */
+    async getTransactionCount(address, status) {
+        this.checkIfInitialized();
+        if (status) {
+            return Number(await store.httpsProvider.getTransactionCount(address, status));
+        }
+        else {
+            return Number(await store.httpsProvider.getTransactionCount(address));
+        }
+    }
+    getAddressByKey(pk) {
+        return new Wallet(pk).address;
+    }
+    /**
+     * Fetch transactions for specific addresses starting with specific block until last block
+     * @param addresses - array of addresses IN LOWER CASE to fetch transactions (from these addresses and to these addresses)
+     * @param startBlock - number of block to start fetching transactions (if empty fetch only for last block)
+     * @param lastBlock - number of block to last fetching transactions (if empty fetch only for last block)
+     * @param batchSize - block size for asynchronous transaction loading
+     * @returns Promise<BlockchainTransaction> with found transactions and last fetched block
+     */
+    async getTransactions({ addresses, startBlock, lastBlock, batchSize = BLOCK_SIZE_TO_FETCH_TRANSACTION, timeout, }) {
+        this.checkIfInitialized();
+        const blockchainLastBlock = Number(await store.httpsProvider.getBlockNumber());
+        if (lastBlock) {
+            lastBlock = Math.min(lastBlock, blockchainLastBlock);
+        }
+        else {
+            lastBlock = blockchainLastBlock;
+        }
+        if (!startBlock) {
+            startBlock = Math.max(lastBlock - 1000, 0);
+        }
+        const transactionsByAddress = {};
+        const validAddresses = addresses
+            .filter((address) => isAddress(address))
+            .map((address) => address.toLowerCase());
+        if (!validAddresses.length) {
+            return {
+                transactionsByAddress,
+                lastBlock,
+            };
+        }
+        validAddresses.forEach((address) => (transactionsByAddress[address] = []));
+        while (startBlock <= lastBlock) {
+            const requests = [];
+            const batchLastBlock = Math.min(startBlock + batchSize - 1, lastBlock);
+            for (let blockNumber = startBlock; blockNumber <= batchLastBlock; blockNumber++) {
+                const hexedBlockNumber = '0x' + blockNumber.toString(16);
+                requests.push({
+                    jsonrpc: '2.0',
+                    method: 'eth_getBlockByNumber',
+                    params: [hexedBlockNumber, true],
+                });
+            }
+            const blocksResult = await executeBatchAsync(requests, {
+                timeout,
+                throwOnError: true,
+            });
+            blocksResult
+                .map((result) => result.result)
+                .forEach((block) => {
+                if (!block?.transactions)
+                    return;
+                block.transactions.forEach((transaction) => {
+                    if (typeof transaction === 'string') {
+                        return;
+                    }
+                    let address = null;
+                    if (validAddresses.includes(transaction.from))
+                        address = transaction.from;
+                    else if (transaction.to && validAddresses.includes(transaction.to))
+                        address = transaction.to;
+                    if (address) {
+                        transactionsByAddress[address].push({
+                            ...transaction,
+                            timestamp: Number(block.timestamp) * 1000,
+                        });
+                    }
+                });
+            });
+            startBlock = batchLastBlock + 1;
+        }
+        return {
+            transactionsByAddress,
+            lastBlock,
+        };
+    }
+    shutdown() {
+        super.shutdown();
+        store.httpsProvider = undefined;
+        Monitoring.getInstance().shutdownLogging();
+    }
+}
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], BlockchainConnector.prototype, "getBalance", null);
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], BlockchainConnector.prototype, "getTransactionEvents", null);
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], BlockchainConnector.prototype, "transfer", null);
+__decorate([
+    incrementMethodCall(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], BlockchainConnector.prototype, "getTransactions", null);
+export default BlockchainConnector;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BlockchainConnector.js","sourceRoot":"","sources":["../../../src/connectors/BlockchainConnector.ts"],"names":[],"mappings":"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"}

package/dist/mjs/connectors/BlockchainEventsListener.d.ts

@@ -0,0 +1,33 @@
+import { BaseConnector, Config, ReconnectOptions } from './BaseConnector.js';
+import { BaseContract, EventLog } from 'ethers';
+export type WssSubscriptionOnDataFn = (event: EventLog) => Promise<void> | void;
+export type WssSubscriptionOnErrorFn = (error: Error) => Promise<void> | void;
+type UnsubscribeFn = () => Promise<void> | void;
+type SubscribeParams = {
+    unsubscribeAndRemove: UnsubscribeFn;
+    onData: WssSubscriptionOnDataFn;
+    onError: WssSubscriptionOnErrorFn;
+    event: string;
+    contract?: BaseContract;
+};
+type SubscriptionEvent = Omit<SubscribeParams, 'unsubscribeAndRemove'>;
+export default class BlockchainEventsListener extends BaseConnector {
+    private static instance;
+    private isSubscribingBlocked;
+    private reconnectAttemptCount;
+    private constructor();
+    static getInstance(): BlockchainEventsListener;
+    private readonly subscriptions;
+    subscribeEvent(params: SubscriptionEvent): UnsubscribeFn;
+    private resubscribe;
+    unsubscribeAll(): Promise<boolean>;
+    /**
+     * Function for connecting to blockchain using web socket
+     * Needs to run this function before using events
+     */
+    initialize(config: Config): Promise<void>;
+    isInReconnectProcess(): boolean;
+    tryReconnect(config: Config, reconnectOptions: ReconnectOptions): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export {};