@super-protocol/sdk-js 2.1.2 → 2.1.3

package/dist/mjs/types/ValueOfferSlot.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVmFsdWVPZmZlclNsb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHlwZXMvVmFsdWVPZmZlclNsb3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/mjs/types/Web3.d.ts

@@ -0,0 +1,62 @@
+import Web3, { Numbers, TransactionInfo } from 'web3';
+export type BlockchainId = string;
+export type TokenAmount = string;
+export type BlockIndex = number;
+export type BlockInfo = {
+    index: BlockIndex;
+    hash: string | undefined;
+};
+export type EventData = {
+    contract: string;
+    name: string;
+    data: {
+        [key: string]: unknown;
+    };
+};
+export type ExtendedTransactionInfo = TransactionInfo & {
+    timestamp?: number;
+};
+type Filter = Record<string, Numbers | Numbers[] | boolean | boolean[]>;
+export type FilterWithExternalId = Filter & {
+    externalId: string;
+};
+export type EventOptions = {
+    filter?: Filter;
+    toBlock?: number | string;
+    fromBlock?: number | string;
+};
+export type TransactionOptionsRequired = Required<TransactionOptions>;
+export type BlockchainError = {
+    message: string;
+};
+export type TransactionDataOptions = TransactionOptions & {
+    to: string;
+    nonce?: bigint;
+    data?: string;
+    value?: TokenAmount;
+};
+export type TransactionOptions = {
+    from?: string;
+    gas?: bigint;
+    gasPrice?: bigint;
+    gasPriceMultiplier?: number;
+    web3?: Web3;
+};
+export type Transaction = {
+    hash: string;
+    nonce: number;
+    blockHash: string | null;
+    blockNumber: number | null;
+    transactionIndex: number | null;
+    from: string;
+    to: string | null;
+    value: string;
+    gasPrice: string;
+    gas: number;
+    input: string;
+    timestamp: number;
+};
+export type DryRunError = Error & {
+    txErrorMsg: string | null;
+};
+export {};

package/dist/mjs/types/Web3.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2ViMy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90eXBlcy9XZWIzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/mjs/types/blockchainConnector/StorageAccess.d.ts

@@ -0,0 +1,8 @@
+import { ExtendedTransactionInfo } from '../../types/index.js';
+type BlockchainTransaction = {
+    transactionsByAddress: {
+        [p: string]: ExtendedTransactionInfo[];
+    };
+    lastBlock: number;
+};
+export default BlockchainTransaction;

package/dist/mjs/types/blockchainConnector/StorageAccess.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RvcmFnZUFjY2Vzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90eXBlcy9ibG9ja2NoYWluQ29ubmVjdG9yL1N0b3JhZ2VBY2Nlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/mjs/types/index.d.ts

@@ -0,0 +1,22 @@
+export * from './Compressor.js';
+export * from './Consensus.js';
+export * from './DepositInfo.js';
+export * from './EtlModel.js';
+export * from './Events.js';
+export * from './HardwareInfo.js';
+export * from './Marks.js';
+export * from './Offer.js';
+export * from './OptionInfo.js';
+export * from './Order.js';
+export * from './OrderUsage.js';
+export * from './Origins.js';
+export * from './Provider.js';
+export * from './ResourceLoader.js';
+export * from './SlotInfo.js';
+export * from './SlotUsage.js';
+export * from './Superpro.js';
+export * from './TeeOfferInfo.js';
+export * from './TeeOfferOption.js';
+export * from './TeeOfferSlot.js';
+export * from './ValueOfferSlot.js';
+export * from './Web3.js';

package/dist/mjs/types/index.js

@@ -0,0 +1,23 @@
+export * from './Compressor.js';
+export * from './Consensus.js';
+export * from './DepositInfo.js';
+export * from './EtlModel.js';
+export * from './Events.js';
+export * from './HardwareInfo.js';
+export * from './Marks.js';
+export * from './Offer.js';
+export * from './OptionInfo.js';
+export * from './Order.js';
+export * from './OrderUsage.js';
+export * from './Origins.js';
+export * from './Provider.js';
+export * from './ResourceLoader.js';
+export * from './SlotInfo.js';
+export * from './SlotUsage.js';
+export * from './Superpro.js';
+export * from './TeeOfferInfo.js';
+export * from './TeeOfferOption.js';
+export * from './TeeOfferSlot.js';
+export * from './ValueOfferSlot.js';
+export * from './Web3.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxXQUFXLENBQUMifQ==

package/dist/mjs/types/storage/StorageAccess.d.ts

@@ -0,0 +1,7 @@
+import { StorageType } from '@super-protocol/dto-js';
+type StorageAccess = {
+    storageType: StorageType;
+    credentials: any;
+    maximumConcurrent?: number;
+};
+export default StorageAccess;

package/dist/mjs/types/storage/StorageAccess.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RvcmFnZUFjY2Vzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90eXBlcy9zdG9yYWdlL1N0b3JhZ2VBY2Nlc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/mjs/types/storage/StorageFileAccess.d.ts

@@ -0,0 +1,5 @@
+import StorageAccess from './StorageAccess.js';
+type StorageFileAccess = StorageAccess & {
+    filepath: string;
+};
+export default StorageFileAccess;

package/dist/mjs/types/storage/StorageFileAccess.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RvcmFnZUZpbGVBY2Nlc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHlwZXMvc3RvcmFnZS9TdG9yYWdlRmlsZUFjY2Vzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/mjs/types/storage/StorageObject.d.ts

@@ -0,0 +1,8 @@
+type StorageObject = {
+    name: string;
+    size: number;
+    isFolder?: boolean;
+    childrenCount?: number;
+    createdAt: Date;
+};
+export default StorageObject;

package/dist/mjs/types/storage/StorageObject.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RvcmFnZU9iamVjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90eXBlcy9zdG9yYWdlL1N0b3JhZ2VPYmplY3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/mjs/utils/Monitoring.d.ts

@@ -0,0 +1,11 @@
+export declare class Monitoring {
+    private static instance;
+    private logger;
+    private contractMethodCalls;
+    private interval?;
+    private constructor();
+    static getInstance(): Monitoring;
+    initializeLogging(): void;
+    shutdownLogging(): void;
+    incrementCall(methodName: string): void;
+}

package/dist/mjs/utils/Monitoring.js

@@ -0,0 +1,42 @@
+import rootLogger from '../logger.js';
+export class Monitoring {
+    static instance;
+    logger = rootLogger.child({ className: 'Monitoring' });
+    contractMethodCalls = new Map();
+    interval;
+    constructor() { }
+    static getInstance() {
+        if (!Monitoring.instance) {
+            Monitoring.instance = new Monitoring();
+        }
+        return Monitoring.instance;
+    }
+    initializeLogging() {
+        const checkInterval = process.env.PRINT_CONTRACT_CALLS_INTERVAL || 300000;
+        this.shutdownLogging();
+        const startTs = Date.now();
+        this.interval = setInterval(() => {
+            this.contractMethodCalls.forEach((value, key) => this.logger.debug({
+                methodName: key,
+                calledTimes: value,
+            }));
+            const totalCalls = Array.from(this.contractMethodCalls.values()).reduce((acc, curr) => acc + curr, 0);
+            const timeSpend = Math.floor((Date.now() - startTs) / (60 * 1000));
+            this.logger.debug({
+                timeSpend: timeSpend + ' min',
+                totalCalls,
+            }, 'Contract methods calls');
+        }, +checkInterval);
+    }
+    shutdownLogging() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+    }
+    incrementCall(methodName) {
+        const prevValue = this.contractMethodCalls.get(methodName) || 0;
+        this.contractMethodCalls.set(methodName, prevValue + 1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/utils/NonceTracker.d.ts

@@ -0,0 +1,19 @@
+import Web3 from 'web3';
+declare class NonceTracker {
+    private web3;
+    private address;
+    private logger;
+    private txCount?;
+    private transactionsOnHold;
+    private countOfPendingTransactions;
+    constructor(web3: Web3, address: string);
+    initAccount(): Promise<void>;
+    getNonce(): bigint;
+    consumeNonce(): bigint;
+    onTransactionStartPublishing(): Promise<void>;
+    onTransactionPublished(nonce: bigint): void;
+    onTransactionError(): Promise<void>;
+    private waitForPendingTransactions;
+    private sendHoldTransactions;
+}
+export default NonceTracker;

package/dist/mjs/utils/NonceTracker.js

@@ -0,0 +1,73 @@
+import rootLogger from '../logger.js';
+class NonceTracker {
+    web3;
+    address;
+    logger;
+    txCount;
+    transactionsOnHold;
+    countOfPendingTransactions = 0;
+    constructor(web3, address) {
+        this.web3 = web3;
+        this.address = address;
+        this.logger = rootLogger.child({ className: 'NonceTracker', address });
+        this.logger.trace('Created NonceTracker');
+    }
+    async initAccount() {
+        this.txCount = await this.web3.eth.getTransactionCount(this.address);
+        this.logger.trace(`Initialized ${this.address} account with nonce: ${this.txCount}`);
+    }
+    getNonce() {
+        if (this.txCount === undefined)
+            throw Error(`NonceTracker for address ${this.address} is not initialized`);
+        this.logger.trace(`Get nonce: ${this.txCount}`);
+        return this.txCount;
+    }
+    consumeNonce() {
+        if (this.txCount === undefined)
+            throw Error(`NonceTracker for address ${this.address} is not initialized`);
+        this.logger.trace(`Consume nonce: ${this.txCount}. Next nonce: ${this.txCount + BigInt(1)}`);
+        return this.txCount++;
+    }
+    async onTransactionStartPublishing() {
+        if (this.transactionsOnHold) {
+            await this.waitForPendingTransactions();
+        }
+        this.countOfPendingTransactions++;
+    }
+    onTransactionPublished(nonce) {
+        this.countOfPendingTransactions--;
+        if (this.countOfPendingTransactions === 0) {
+            this.logger.trace(`last tx published with nonce: ${nonce}. State nonce ${this.txCount}`);
+            void this.sendHoldTransactions();
+        }
+    }
+    async onTransactionError() {
+        this.countOfPendingTransactions--;
+        if (!this.transactionsOnHold)
+            this.transactionsOnHold = [];
+        if (this.countOfPendingTransactions === 0) {
+            await this.sendHoldTransactions();
+        }
+        else {
+            await this.waitForPendingTransactions();
+        }
+    }
+    waitForPendingTransactions() {
+        return new Promise((resolve) => {
+            if (!this.transactionsOnHold)
+                return resolve();
+            this.transactionsOnHold.push(() => {
+                resolve();
+            });
+        });
+    }
+    async sendHoldTransactions() {
+        if (!this.transactionsOnHold)
+            return;
+        await this.initAccount();
+        this.transactionsOnHold.forEach((callback) => callback());
+        this.transactionsOnHold = undefined;
+    }
+}
+export default NonceTracker;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm9uY2VUcmFja2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL05vbmNlVHJhY2tlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLFVBQVUsTUFBTSxjQUFjLENBQUM7QUFHdEMsTUFBTSxZQUFZO0lBTUk7SUFBb0I7SUFMaEMsTUFBTSxDQUFTO0lBQ2YsT0FBTyxDQUFVO0lBQ2pCLGtCQUFrQixDQUE2QjtJQUMvQywwQkFBMEIsR0FBRyxDQUFDLENBQUM7SUFFdkMsWUFBb0IsSUFBVSxFQUFVLE9BQWU7UUFBbkMsU0FBSSxHQUFKLElBQUksQ0FBTTtRQUFVLFlBQU8sR0FBUCxPQUFPLENBQVE7UUFDckQsSUFBSSxDQUFDLE1BQU0sR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDLEVBQUUsU0FBUyxFQUFFLGNBQWMsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZFLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLHNCQUFzQixDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUVNLEtBQUssQ0FBQyxXQUFXO1FBQ3RCLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDckUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsZUFBZSxJQUFJLENBQUMsT0FBTyx3QkFBd0IsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDdkYsQ0FBQztJQUVNLFFBQVE7UUFDYixJQUFJLElBQUksQ0FBQyxPQUFPLEtBQUssU0FBUztZQUM1QixNQUFNLEtBQUssQ0FBQyw0QkFBNEIsSUFBSSxDQUFDLE9BQU8scUJBQXFCLENBQUMsQ0FBQztRQUU3RSxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxjQUFjLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBRWhELE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRU0sWUFBWTtRQUNqQixJQUFJLElBQUksQ0FBQyxPQUFPLEtBQUssU0FBUztZQUM1QixNQUFNLEtBQUssQ0FBQyw0QkFBNEIsSUFBSSxDQUFDLE9BQU8scUJBQXFCLENBQUMsQ0FBQztRQUU3RSxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsSUFBSSxDQUFDLE9BQU8saUJBQWlCLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUU3RixPQUFPLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUN4QixDQUFDO0lBRU0sS0FBSyxDQUFDLDRCQUE0QjtRQUN2QyxJQUFJLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1lBQzVCLE1BQU0sSUFBSSxDQUFDLDBCQUEwQixFQUFFLENBQUM7UUFDMUMsQ0FBQztRQUNELElBQUksQ0FBQywwQkFBMEIsRUFBRSxDQUFDO0lBQ3BDLENBQUM7SUFFTSxzQkFBc0IsQ0FBQyxLQUFhO1FBQ3pDLElBQUksQ0FBQywwQkFBMEIsRUFBRSxDQUFDO1FBRWxDLElBQUksSUFBSSxDQUFDLDBCQUEwQixLQUFLLENBQUMsRUFBRSxDQUFDO1lBQzFDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLGlDQUFpQyxLQUFLLGlCQUFpQixJQUFJLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUV6RixLQUFLLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxDQUFDO1FBQ25DLENBQUM7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLGtCQUFrQjtRQUM3QixJQUFJLENBQUMsMEJBQTBCLEVBQUUsQ0FBQztRQUNsQyxJQUFJLENBQUMsSUFBSSxDQUFDLGtCQUFrQjtZQUFFLElBQUksQ0FBQyxrQkFBa0IsR0FBRyxFQUFFLENBQUM7UUFFM0QsSUFBSSxJQUFJLENBQUMsMEJBQTBCLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDMUMsTUFBTSxJQUFJLENBQUMsb0JBQW9CLEVBQUUsQ0FBQztRQUNwQyxDQUFDO2FBQU0sQ0FBQztZQUNOLE1BQU0sSUFBSSxDQUFDLDBCQUEwQixFQUFFLENBQUM7UUFDMUMsQ0FBQztJQUNILENBQUM7SUFFTywwQkFBMEI7UUFDaEMsT0FBTyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQ25DLElBQUksQ0FBQyxJQUFJLENBQUMsa0JBQWtCO2dCQUFFLE9BQU8sT0FBTyxFQUFFLENBQUM7WUFDL0MsSUFBSSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUU7Z0JBQ2hDLE9BQU8sRUFBRSxDQUFDO1lBQ1osQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxLQUFLLENBQUMsb0JBQW9CO1FBQ2hDLElBQUksQ0FBQyxJQUFJLENBQUMsa0JBQWtCO1lBQUUsT0FBTztRQUVyQyxNQUFNLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUN6QixJQUFJLENBQUMsa0JBQWtCLENBQUMsT0FBTyxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO1FBQzFELElBQUksQ0FBQyxrQkFBa0IsR0FBRyxTQUFTLENBQUM7SUFDdEMsQ0FBQztDQUNGO0FBRUQsZUFBZSxZQUFZLENBQUMifQ==

package/dist/mjs/utils/PubSub.d.ts

@@ -0,0 +1,9 @@
+type Listener<Message> = (message: Message) => void;
+export default class PubSub<Event, Message> {
+    private subscriptions;
+    subscribe(event: Event, listener: Listener<Message>): () => void;
+    unsubscribe(event: Event, listener: Listener<Message>): void;
+    publish(event: Event, message: Message): void;
+    clear(event?: Event): void;
+}
+export {};

package/dist/mjs/utils/PubSub.js

@@ -0,0 +1,32 @@
+export default class PubSub {
+    subscriptions = new Map();
+    subscribe(event, listener) {
+        this.subscriptions.set(event, (this.subscriptions.get(event) || []).concat(listener));
+        return () => {
+            this.unsubscribe(event, listener);
+        };
+    }
+    unsubscribe(event, listener) {
+        const eventListeners = this.subscriptions.get(event);
+        if (eventListeners) {
+            this.subscriptions.set(event, eventListeners.filter((l) => l !== listener));
+        }
+    }
+    publish(event, message) {
+        const eventListeners = this.subscriptions.get(event);
+        if (eventListeners) {
+            eventListeners.forEach((listener) => {
+                listener(message);
+            });
+        }
+    }
+    clear(event) {
+        if (event) {
+            this.subscriptions.delete(event);
+        }
+        else {
+            this.subscriptions.clear();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUHViU3ViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL1B1YlN1Yi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsT0FBTyxPQUFPLE1BQU07SUFDakIsYUFBYSxHQUFvQyxJQUFJLEdBQUcsRUFBRSxDQUFDO0lBRW5FLFNBQVMsQ0FBQyxLQUFZLEVBQUUsUUFBMkI7UUFDakQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7UUFFdEYsT0FBTyxHQUFHLEVBQUU7WUFDVixJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssRUFBRSxRQUFRLENBQUMsQ0FBQztRQUNwQyxDQUFDLENBQUM7SUFDSixDQUFDO0lBRUQsV0FBVyxDQUFDLEtBQVksRUFBRSxRQUEyQjtRQUNuRCxNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNyRCxJQUFJLGNBQWMsRUFBRSxDQUFDO1lBQ25CLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUNwQixLQUFLLEVBQ0wsY0FBYyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLFFBQVEsQ0FBQyxDQUM3QyxDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7SUFFRCxPQUFPLENBQUMsS0FBWSxFQUFFLE9BQWdCO1FBQ3BDLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3JELElBQUksY0FBYyxFQUFFLENBQUM7WUFDbkIsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFO2dCQUNsQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDcEIsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO0lBQ0gsQ0FBQztJQUVELEtBQUssQ0FBQyxLQUFhO1FBQ2pCLElBQUksS0FBSyxFQUFFLENBQUM7WUFDVixJQUFJLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNuQyxDQUFDO2FBQU0sQ0FBQztZQUNOLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDN0IsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

package/dist/mjs/utils/TxManager.d.ts

@@ -0,0 +1,25 @@
+import { TransactionReceipt } from 'web3';
+import { TransactionOptions, TransactionDataOptions } from '../types/index.js';
+import Web3 from 'web3';
+import { NonPayableMethodObject } from 'web3-eth-contract';
+declare class Web3TransactionError extends Error {
+    readonly originalError: unknown;
+    constructor(originalError: unknown, message: string);
+}
+export declare class Web3TransactionRevertedByEvmError extends Web3TransactionError {
+    constructor(originalError: unknown, message: string);
+}
+declare class TxManager {
+    private static web3;
+    private static logger;
+    private static nonceTrackers;
+    private static queues;
+    static init(web3: Web3): void;
+    private static checkIfInitialized;
+    static initAccount(address: string): Promise<void>;
+    static execute(transaction: NonPayableMethodObject, transactionOptions?: TransactionOptions, to?: string): Promise<TransactionReceipt>;
+    static publishTransaction(txData: TransactionDataOptions, transactionOptions?: TransactionOptions, transactionCall?: NonPayableMethodObject): Promise<TransactionReceipt>;
+    static dryRun<SpecialOutput = unknown>(transaction: NonPayableMethodObject, transactionOptions?: TransactionOptions): Promise<SpecialOutput>;
+    private static _publishTransaction;
+}
+export default TxManager;

package/dist/mjs/utils/TxManager.js

@@ -0,0 +1,162 @@
+import NonceTracker from './NonceTracker.js';
+import rootLogger from '../logger.js';
+import store from '../store.js';
+import { checkForUsingExternalTxManager, checkIfActionAccountInitialized, createTransactionOptions, multiplyBigIntByNumber, } from './helper.js';
+import Superpro from '../staticModels/Superpro.js';
+import { defaultGasLimit } from '../constants.js';
+import lodash from 'lodash';
+import Bottleneck from 'bottleneck';
+class Web3TransactionError extends Error {
+    originalError;
+    constructor(originalError, message) {
+        super(message);
+        this.name = 'Web3TransactionError';
+        this.originalError = originalError;
+    }
+}
+export class Web3TransactionRevertedByEvmError extends Web3TransactionError {
+    constructor(originalError, message) {
+        super(originalError, message);
+        this.name = 'Web3TransactionRevertedByEvmError';
+    }
+}
+class TxManager {
+    static web3;
+    static logger = rootLogger.child({ className: 'TxManager' });
+    static nonceTrackers = {};
+    static queues = {};
+    static init(web3) {
+        this.web3 = web3;
+    }
+    static checkIfInitialized() {
+        if (!this.web3) {
+            throw Error('TxManager should be initialized before using.');
+        }
+    }
+    static async initAccount(address) {
+        if (this.nonceTrackers[address])
+            return;
+        this.nonceTrackers[address] = new NonceTracker(this.web3, address);
+        await this.nonceTrackers[address].initAccount();
+    }
+    static execute(transaction, transactionOptions, to = Superpro.address) {
+        const txData = {
+            to,
+            data: transaction.encodeABI(),
+        };
+        return TxManager.publishTransaction(txData, transactionOptions, transaction);
+    }
+    static async publishTransaction(txData, transactionOptions, transactionCall) {
+        this.checkIfInitialized();
+        checkIfActionAccountInitialized(transactionOptions);
+        const txOptions = await createTransactionOptions({ ...transactionOptions });
+        if (!txOptions.from) {
+            throw Error('From account is undefined. You should pass it to transactionOptions or init action account.');
+        }
+        const publishTxOptions = {
+            ...txOptions,
+            web3: transactionOptions?.web3 || this.web3,
+            useExternalTxManager: checkForUsingExternalTxManager(transactionOptions),
+        };
+        if (!this.queues[publishTxOptions.from]) {
+            this.queues[publishTxOptions.from] = new Bottleneck({
+                maxConcurrent: store.txConcurrency,
+                minTime: store.txIntervalMs,
+            });
+        }
+        return this.queues[publishTxOptions.from].schedule(() => TxManager._publishTransaction(txData, publishTxOptions, transactionCall));
+    }
+    static async dryRun(transaction, transactionOptions) {
+        const from = transactionOptions?.from ?? store.actionAccount;
+        try {
+            return await transaction.call({ from });
+        }
+        catch (e) {
+            e.txErrorMsg = e.data.message || 'Error text is undefined';
+            throw e;
+        }
+    }
+    static async _publishTransaction(txData, transactionOptions, transactionCall) {
+        const { from, gas, gasPrice, gasPriceMultiplier, web3 } = transactionOptions;
+        txData = {
+            ...txData,
+            from,
+            gas,
+            gasPrice,
+            gasPriceMultiplier,
+        };
+        if (transactionCall) {
+            let estimatedGas;
+            try {
+                estimatedGas = await transactionCall.estimateGas(txData);
+            }
+            catch (e) {
+                TxManager.logger.debug({ error: e }, 'Fail to calculate estimated gas');
+                estimatedGas = defaultGasLimit;
+            }
+            txData.gas = multiplyBigIntByNumber(estimatedGas, store.gasLimitMultiplier);
+            // defaultGasLimit is max gas limit
+            txData.gas = txData.gas < defaultGasLimit ? txData.gas : defaultGasLimit;
+            if (transactionOptions.gas) {
+                if (transactionOptions.gas < estimatedGas) {
+                    TxManager.logger.warn({
+                        estimated: estimatedGas,
+                        specified: transactionOptions.gas,
+                    }, 'Fail to calculate estimated gas');
+                }
+                txData.gas = transactionOptions.gas;
+            }
+            txData.gasPrice = multiplyBigIntByNumber(txData.gasPrice, store.gasPriceMultiplier);
+        }
+        let nonceTracker;
+        // TODO: Consider a better way to organize different strategies for publishing transactions.
+        if (!transactionOptions.useExternalTxManager && this.nonceTrackers[transactionOptions.from]) {
+            nonceTracker = this.nonceTrackers[transactionOptions.from];
+            await nonceTracker.onTransactionStartPublishing();
+            txData.nonce = nonceTracker.consumeNonce();
+        }
+        const signingKey = store.keys[transactionOptions.from];
+        try {
+            let transactionResultData;
+            if (signingKey) {
+                const signed = await web3.eth.accounts.signTransaction(txData, signingKey);
+                if (!signed.rawTransaction) {
+                    throw new Error('Failed to sign transaction');
+                }
+                TxManager.logger.debug({
+                    txHash: signed.transactionHash,
+                    txData: lodash.omit(txData, ['data']),
+                }, 'Publishing signed transaction');
+                transactionResultData = await web3.eth.sendSignedTransaction(signed.rawTransaction);
+                TxManager.logger.debug({
+                    txHash: signed.transactionHash,
+                    txBlockNumber: transactionResultData.blockNumber,
+                    txGasUsed: transactionResultData.gasUsed,
+                }, 'Transaction result');
+            }
+            else {
+                TxManager.logger.debug({
+                    txData: lodash.omit(txData, ['data']),
+                }, 'Publishing unsigned transaction');
+                transactionResultData = await web3.eth.sendTransaction(txData);
+            }
+            if (nonceTracker)
+                nonceTracker.onTransactionPublished(txData.nonce);
+            return transactionResultData;
+        }
+        catch (e) {
+            const message = 'Error during transaction execution';
+            TxManager.logger.error(e, message);
+            if (nonceTracker)
+                await nonceTracker.onTransactionError();
+            if (e.message?.includes('Transaction has been reverted by the EVM')) {
+                throw new Web3TransactionRevertedByEvmError(e, message);
+            }
+            else {
+                throw new Web3TransactionError(e, message);
+            }
+        }
+    }
+}
+export default TxManager;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/utils/compressors/GzipCompressor.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Compression_TYPE } from '../../proto/Compression.js';
+import { Compressor } from '../../types/Compressor.js';
+export declare class GzipCompressor<T> implements Compressor<T> {
+    static type: Compression_TYPE;
+    compress(content: T): Promise<Buffer>;
+    decompress(bytes: Buffer): Promise<T>;
+}

package/dist/mjs/utils/compressors/GzipCompressor.js

@@ -0,0 +1,15 @@
+import nodeGzip from 'node-gzip';
+import { Compression_TYPE } from '../../proto/Compression.js';
+const { gzip, ungzip } = nodeGzip;
+export class GzipCompressor {
+    static type = Compression_TYPE.GZIP;
+    compress(content) {
+        const stringified = JSON.stringify(content);
+        return gzip(stringified);
+    }
+    async decompress(bytes) {
+        const stringified = await ungzip(bytes);
+        return JSON.parse(stringified.toString());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3ppcENvbXByZXNzb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY29tcHJlc3NvcnMvR3ppcENvbXByZXNzb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxRQUFRLE1BQU0sV0FBVyxDQUFDO0FBQ2pDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRzlELE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEdBQUcsUUFBUSxDQUFDO0FBRWxDLE1BQU0sT0FBTyxjQUFjO0lBQ2xCLE1BQU0sQ0FBQyxJQUFJLEdBQUcsZ0JBQWdCLENBQUMsSUFBSSxDQUFDO0lBRXBDLFFBQVEsQ0FBQyxPQUFVO1FBQ3hCLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFNUMsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxVQUFVLENBQUMsS0FBYTtRQUNuQyxNQUFNLFdBQVcsR0FBRyxNQUFNLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUV4QyxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDNUMsQ0FBQyJ9

package/dist/mjs/utils/compressors/UncompressedCompressor.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Compression_TYPE } from '../../proto/Compression.js';
+import { Compressor } from '../../types/Compressor.js';
+export declare class UncompressedCompressor<T = unknown> implements Compressor<T> {
+    static type: Compression_TYPE;
+    compress(content: T): Promise<Buffer>;
+    decompress(bytes: Buffer): Promise<T>;
+}

package/dist/mjs/utils/compressors/UncompressedCompressor.js

@@ -0,0 +1,13 @@
+import { Compression_TYPE } from '../../proto/Compression.js';
+export class UncompressedCompressor {
+    static type = Compression_TYPE.Uncompressed;
+    compress(content) {
+        const stringified = JSON.stringify(content);
+        return Promise.resolve(Buffer.from(stringified));
+    }
+    decompress(bytes) {
+        const stringified = bytes.toString();
+        return Promise.resolve(JSON.parse(stringified));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVW5jb21wcmVzc2VkQ29tcHJlc3Nvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9jb21wcmVzc29ycy9VbmNvbXByZXNzZWRDb21wcmVzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRzlELE1BQU0sT0FBTyxzQkFBc0I7SUFDMUIsTUFBTSxDQUFDLElBQUksR0FBRyxnQkFBZ0IsQ0FBQyxZQUFZLENBQUM7SUFFNUMsUUFBUSxDQUFDLE9BQVU7UUFDeEIsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU1QyxPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFFTSxVQUFVLENBQUMsS0FBYTtRQUM3QixNQUFNLFdBQVcsR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUM7UUFFckMsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztJQUNsRCxDQUFDIn0=

package/dist/mjs/utils/compressors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './GzipCompressor.js';
+export * from './UncompressedCompressor.js';

package/dist/mjs/utils/compressors/index.js

@@ -0,0 +1,3 @@
+export * from './GzipCompressor.js';
+export * from './UncompressedCompressor.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY29tcHJlc3NvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDZCQUE2QixDQUFDIn0=