@super-protocol/sdk-js 2.1.4-beta.0 → 2.1.4-beta.3

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

@@ -0,0 +1,13 @@
+import { OptionInfo, OptionInfoRaw } from './OptionInfo';
+import { BlockchainId } from './Web3';
+import { SlotUsage } from './SlotUsage';
+export type TeeOfferOptionBase = {
+    id: BlockchainId;
+    usage: SlotUsage;
+};
+export type TeeOfferOption = TeeOfferOptionBase & {
+    info: OptionInfo;
+};
+export type TeeOfferOptionRaw = TeeOfferOptionBase & {
+    info: OptionInfoRaw;
+};

package/dist/mjs/types/TeeOfferOption.js

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

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

@@ -0,0 +1,8 @@
+import { BlockchainId } from './Web3';
+import { SlotInfo } from './SlotInfo';
+import { SlotUsage } from './SlotUsage';
+export type TeeOfferSlot = {
+    id: BlockchainId;
+    info: SlotInfo;
+    usage: SlotUsage;
+};

package/dist/mjs/types/TeeOfferSlot.js

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

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

@@ -0,0 +1,16 @@
+import { OptionInfo, OptionInfoRaw } from './OptionInfo';
+import { BlockchainId } from './Web3';
+import { SlotInfo } from './SlotInfo';
+import { SlotUsage } from './SlotUsage';
+type ValueOfferSlotBase = {
+    id: BlockchainId;
+    info: SlotInfo;
+    usage: SlotUsage;
+};
+export type ValueOfferSlot = ValueOfferSlotBase & {
+    option: OptionInfo;
+};
+export type ValueOfferSlotRaw = ValueOfferSlotBase & {
+    option: OptionInfoRaw;
+};
+export {};

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';
+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';
+export * from './Consensus';
+export * from './DepositInfo';
+export * from './EtlModel';
+export * from './Events';
+export * from './HardwareInfo';
+export * from './Marks';
+export * from './Offer';
+export * from './OptionInfo';
+export * from './Order';
+export * from './OrderUsage';
+export * from './Origins';
+export * from './Provider';
+export * from './ResourceLoader';
+export * from './SlotInfo';
+export * from './SlotUsage';
+export * from './Superpro';
+export * from './TeeOfferInfo';
+export * from './TeeOfferOption';
+export * from './TeeOfferSlot';
+export * from './ValueOfferSlot';
+export * from './Web3';

package/dist/mjs/types/index.js

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

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';
+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';
+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';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm9uY2VUcmFja2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL05vbmNlVHJhY2tlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLFVBQVUsTUFBTSxXQUFXLENBQUM7QUFHbkMsTUFBTSxZQUFZO0lBTUk7SUFBb0I7SUFMaEMsTUFBTSxDQUFTO0lBQ2YsT0FBTyxDQUFVO0lBQ2pCLGtCQUFrQixDQUE2QjtJQUMvQywwQkFBMEIsR0FBRyxDQUFDLENBQUM7SUFFdkMsWUFBb0IsSUFBVSxFQUFVLE9BQWU7UUFBbkMsU0FBSSxHQUFKLElBQUksQ0FBTTtRQUFVLFlBQU8sR0FBUCxPQUFPLENBQVE7UUFDckQsSUFBSSxDQUFDLE1BQU0sR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDLEVBQUUsU0FBUyxFQUFFLGNBQWMsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZFLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLHNCQUFzQixDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUVNLEtBQUssQ0FBQyxXQUFXO1FBQ3RCLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDckUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsZUFBZSxJQUFJLENBQUMsT0FBTyx3QkFBd0IsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDdkYsQ0FBQztJQUVNLFFBQVE7UUFDYixJQUFJLElBQUksQ0FBQyxPQUFPLEtBQUssU0FBUztZQUM1QixNQUFNLEtBQUssQ0FBQyw0QkFBNEIsSUFBSSxDQUFDLE9BQU8scUJBQXFCLENBQUMsQ0FBQztRQUU3RSxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxjQUFjLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBRWhELE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRU0sWUFBWTtRQUNqQixJQUFJLElBQUksQ0FBQyxPQUFPLEtBQUssU0FBUztZQUM1QixNQUFNLEtBQUssQ0FBQyw0QkFBNEIsSUFBSSxDQUFDLE9BQU8scUJBQXFCLENBQUMsQ0FBQztRQUU3RSxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsSUFBSSxDQUFDLE9BQU8saUJBQWlCLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUU3RixPQUFPLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUN4QixDQUFDO0lBRU0sS0FBSyxDQUFDLDRCQUE0QjtRQUN2QyxJQUFJLElBQUksQ0FBQyxrQkFBa0IsRUFBRTtZQUMzQixNQUFNLElBQUksQ0FBQywwQkFBMEIsRUFBRSxDQUFDO1NBQ3pDO1FBQ0QsSUFBSSxDQUFDLDBCQUEwQixFQUFFLENBQUM7SUFDcEMsQ0FBQztJQUVNLHNCQUFzQixDQUFDLEtBQWE7UUFDekMsSUFBSSxDQUFDLDBCQUEwQixFQUFFLENBQUM7UUFFbEMsSUFBSSxJQUFJLENBQUMsMEJBQTBCLEtBQUssQ0FBQyxFQUFFO1lBQ3pDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLGlDQUFpQyxLQUFLLGlCQUFpQixJQUFJLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUV6RixLQUFLLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxDQUFDO1NBQ2xDO0lBQ0gsQ0FBQztJQUVNLEtBQUssQ0FBQyxrQkFBa0I7UUFDN0IsSUFBSSxDQUFDLDBCQUEwQixFQUFFLENBQUM7UUFDbEMsSUFBSSxDQUFDLElBQUksQ0FBQyxrQkFBa0I7WUFBRSxJQUFJLENBQUMsa0JBQWtCLEdBQUcsRUFBRSxDQUFDO1FBRTNELElBQUksSUFBSSxDQUFDLDBCQUEwQixLQUFLLENBQUMsRUFBRTtZQUN6QyxNQUFNLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxDQUFDO1NBQ25DO2FBQU07WUFDTCxNQUFNLElBQUksQ0FBQywwQkFBMEIsRUFBRSxDQUFDO1NBQ3pDO0lBQ0gsQ0FBQztJQUVPLDBCQUEwQjtRQUNoQyxPQUFPLElBQUksT0FBTyxDQUFPLENBQUMsT0FBTyxFQUFFLEVBQUU7WUFDbkMsSUFBSSxDQUFDLElBQUksQ0FBQyxrQkFBa0I7Z0JBQUUsT0FBTyxPQUFPLEVBQUUsQ0FBQztZQUMvQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRTtnQkFDaEMsT0FBTyxFQUFFLENBQUM7WUFDWixDQUFDLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVPLEtBQUssQ0FBQyxvQkFBb0I7UUFDaEMsSUFBSSxDQUFDLElBQUksQ0FBQyxrQkFBa0I7WUFBRSxPQUFPO1FBRXJDLE1BQU0sSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7UUFDMUQsSUFBSSxDQUFDLGtCQUFrQixHQUFHLFNBQVMsQ0FBQztJQUN0QyxDQUFDO0NBQ0Y7QUFFRCxlQUFlLFlBQVksQ0FBQyJ9

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUHViU3ViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL1B1YlN1Yi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsT0FBTyxPQUFPLE1BQU07SUFDakIsYUFBYSxHQUFvQyxJQUFJLEdBQUcsRUFBRSxDQUFDO0lBRW5FLFNBQVMsQ0FBQyxLQUFZLEVBQUUsUUFBMkI7UUFDakQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7UUFFdEYsT0FBTyxHQUFHLEVBQUU7WUFDVixJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssRUFBRSxRQUFRLENBQUMsQ0FBQztRQUNwQyxDQUFDLENBQUM7SUFDSixDQUFDO0lBRUQsV0FBVyxDQUFDLEtBQVksRUFBRSxRQUEyQjtRQUNuRCxNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNyRCxJQUFJLGNBQWMsRUFBRTtZQUNsQixJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FDcEIsS0FBSyxFQUNMLGNBQWMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsS0FBSyxRQUFRLENBQUMsQ0FDN0MsQ0FBQztTQUNIO0lBQ0gsQ0FBQztJQUVELE9BQU8sQ0FBQyxLQUFZLEVBQUUsT0FBZ0I7UUFDcEMsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDckQsSUFBSSxjQUFjLEVBQUU7WUFDbEIsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFO2dCQUNsQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDcEIsQ0FBQyxDQUFDLENBQUM7U0FDSjtJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsS0FBYTtRQUNqQixJQUFJLEtBQUssRUFBRTtZQUNULElBQUksQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1NBQ2xDO2FBQU07WUFDTCxJQUFJLENBQUMsYUFBYSxDQUFDLEtBQUssRUFBRSxDQUFDO1NBQzVCO0lBQ0gsQ0FBQztDQUNGIn0=

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

@@ -0,0 +1,25 @@
+import { TransactionReceipt } from 'web3';
+import { TransactionOptions, TransactionDataOptions } from '../types';
+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';
+import rootLogger from '../logger';
+import store from '../store';
+import { checkForUsingExternalTxManager, checkIfActionAccountInitialized, createTransactionOptions, multiplyBigIntByNumber, } from './helper';
+import Superpro from '../staticModels/Superpro';
+import { defaultGasLimit } from '../constants';
+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';
+import { Compressor } from '../../types/Compressor';
+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,14 @@
+import { gzip, ungzip } from 'node-gzip';
+import { Compression_TYPE } from '../../proto/Compression';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3ppcENvbXByZXNzb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvY29tcHJlc3NvcnMvR3ppcENvbXByZXNzb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDekMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHM0QsTUFBTSxPQUFPLGNBQWM7SUFDbEIsTUFBTSxDQUFDLElBQUksR0FBRyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUM7SUFFcEMsUUFBUSxDQUFDLE9BQVU7UUFDeEIsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU1QyxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUMzQixDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVUsQ0FBQyxLQUFhO1FBQ25DLE1BQU0sV0FBVyxHQUFHLE1BQU0sTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBRXhDLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUM1QyxDQUFDIn0=