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

package/dist/mjs/staticModels/ModelPackager.js

@@ -0,0 +1,45 @@
+import { Compression } from '../proto/Compression.js';
+import { GzipCompressor, UncompressedCompressor } from '../utils/compressors/index.js';
+export class ModelPackager {
+    static compressors = [GzipCompressor, UncompressedCompressor];
+    /**
+     * Compressing message with best algorithm
+     *
+     * @param message - message
+     * @returns Compressed message in bytes representation
+     */
+    static async pack(message) {
+        const promises = ModelPackager.compressors.map(async (Compressor) => {
+            const compressorInstance = new Compressor();
+            const data = await compressorInstance.compress(message);
+            return {
+                compressionType: Compressor.type,
+                data,
+                size: data.byteLength,
+            };
+        });
+        const options = await Promise.all(promises);
+        options.sort((first, second) => first.size - second.size);
+        const minimal = options[0];
+        const encoded = Compression.encode({
+            type: minimal.compressionType,
+            data: new Uint8Array(minimal.data),
+        }).finish();
+        return Buffer.from(encoded);
+    }
+    /**
+     * Uncompressing message
+     *
+     * @param message - message with bytes representation
+     * @returns original message
+     */
+    static unpack(message) {
+        const decoded = Compression.decode(new Uint8Array(message));
+        const Compressor = ModelPackager.compressors.find((CompressorClass) => CompressorClass.type === decoded.type);
+        if (!Compressor) {
+            throw new Error(`Cannot unpack message. Compressor ${decoded.type} isn't supported`);
+        }
+        return new Compressor().decompress(Buffer.from(decoded.data));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/staticModels/ProviderRewards.d.ts

@@ -0,0 +1,5 @@
+declare class ProviderRewards {
+    static get address(): string;
+    static binarySearchValuableEpochPosition(array: number[], epochIndex: number): number;
+}
+export default ProviderRewards;

package/dist/mjs/staticModels/ProviderRewards.js

@@ -0,0 +1,76 @@
+// import rootLogger from '../logger.js';
+import Superpro from './Superpro.js';
+// import {
+//   EpochInfo,
+//   TransactionOptions,
+//   BlockInfo,
+//   TokenAmount,
+//   OfferType,
+//   ConsensusBenchmarkPriceMultipliers,
+//   ClaimRewardsArgs,
+// } from '../types/index.js';
+// import {
+//   checkIfActionAccountInitialized,
+//   cleanWeb3Data,
+//   formatPriceMultipliers,
+//   formatEpochIndexes,
+//   incrementMethodCall,
+// } from '../utils/helper.js';
+// import TxManager from '../utils/TxManager.js';
+// import { BlockchainConnector, BlockchainEventsListener } from '../connectors/index.js';
+// import { EventLog } from 'web3-eth-contract';
+// import { ConsensusBenchmark } from '@super-protocol/dto-js';
+// import {
+//   WssSubscriptionOnDataFn,
+//   WssSubscriptionOnErrorFn,
+// } from '../connectors/BlockchainEventsListener.js';
+// const EPOCH_INDEXES_REQUEST_BATCH_SIZE = 1000;
+// const BENCHMARK_REQUEST_BATCH_SIZE = 30; // expected response less then 100k bytes
+// type ContractMethod<T> = (...args: any[]) => Promise<T[]>;
+class ProviderRewards {
+    // private static readonly logger = rootLogger.child({ className: 'ProviderRewards' });
+    static get address() {
+        return Superpro.address;
+    }
+    // The functions below will be needed in the implementation of the following tasks
+    // private static async batchCall<T>(
+    //   method: ContractMethod<T>,
+    //   arrayArgs: any[],
+    //   batchSize: number,
+    //   formatFn: (data: any) => T[],
+    // ): Promise<T[]> {
+    //   const results: T[] = [];
+    //   for (let i = 0; i < arrayArgs[0].length; i += batchSize) {
+    //     const batch: any[] = [];
+    //     for (const arg of arrayArgs) {
+    //       batch.push(arg.slice(i, i + batchSize));
+    //     }
+    //     const result = await method(...batch);
+    //     results.push(...formatFn(result));
+    //   }
+    //   return results;
+    // }
+    static binarySearchValuableEpochPosition(array, epochIndex) {
+        if (epochIndex > array[array.length - 1])
+            return array.length - 1;
+        let left = 0;
+        let right = array.length - 2;
+        let foundIndex = -1;
+        while (left <= right) {
+            const mid = Math.floor((left + right) / 2);
+            if (epochIndex > array[mid] && epochIndex <= array[mid + 1]) {
+                foundIndex = mid;
+                break;
+            }
+            else if (epochIndex > array[mid]) {
+                left = mid + 1;
+            }
+            else {
+                right = mid - 1;
+            }
+        }
+        return foundIndex;
+    }
+}
+export default ProviderRewards;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/staticModels/StaticModel.d.ts

@@ -0,0 +1,6 @@
+import { StringifiedEventOutput, EventFilterTuple } from '../utils/helper.js';
+import { App } from '../contracts/typechain-types/index.js';
+declare class StaticModel {
+    static findEventsByFilter<TEventName extends keyof App['filters']>(eventName: TEventName, filter: EventFilterTuple<App['filters'][TEventName]>, fromBlock: number | string, toBlock?: number | string): Promise<StringifiedEventOutput<App['filters'][TEventName]>[]>;
+}
+export default StaticModel;

package/dist/mjs/staticModels/StaticModel.js

@@ -0,0 +1,38 @@
+import BlockchainConnector from '../connectors/BlockchainConnector.js';
+import { cleanWeb3Data } from '../utils/helper.js';
+import store from '../store.js';
+class StaticModel {
+    static async findEventsByFilter(eventName, filter, fromBlock, toBlock = 'latest') {
+        const contract = BlockchainConnector.getInstance().getContract();
+        const eventFragment = contract.interface.getEvent(eventName);
+        const filterValues = filter;
+        const formattedFilter = [];
+        for (let i = 0; i < filterValues.length; i++) {
+            formattedFilter.push(eventFragment.inputs[i].indexed ? filterValues[i] : null);
+        }
+        const topics = contract.interface.encodeFilterTopics(eventName, formattedFilter);
+        const logs = await store.httpsProvider.getLogs({
+            address: contract.target,
+            topics,
+            fromBlock,
+            toBlock,
+        });
+        const parsedArgs = logs.map((log) => contract.interface.parseLog(log).args);
+        const filteredArgs = parsedArgs.filter((args) => {
+            return filterValues.every((filterValue, index) => {
+                if (eventFragment.inputs[index].indexed)
+                    return true;
+                if (filterValue === null || filterValue === undefined)
+                    return true;
+                const eventValue = args[index].toString().toLowerCase();
+                if (Array.isArray(filterValue)) {
+                    return filterValue.map((value) => value.toString().toLowerCase()).includes(eventValue);
+                }
+                return eventValue === filterValue.toString().toLowerCase();
+            });
+        });
+        return filteredArgs.map((args) => cleanWeb3Data(args.toObject(true)));
+    }
+}
+export default StaticModel;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/staticModels/Superpro.d.ts

@@ -0,0 +1,18 @@
+import { ParamName } from '../types/index.js';
+import { App } from '../contracts/typechain-types/index.js';
+declare class Superpro {
+    static address: string;
+    /**
+     * Fetching address of contract by name
+     */
+    static getContractAddress(): string;
+    static getPrimaryTokenAddress(contractInstance?: App): Promise<string>;
+    /**
+     * Fetching config parameter value by name
+     */
+    static getParam(name: ParamName): Promise<string>;
+    static isTokenExists(tokenContractAddress: string): Promise<boolean>;
+    static getTokens(): Promise<Awaited<ReturnType<App['getTokens']>>>;
+    static getTokenStorageRequestFee(tokenAddress: string): Promise<string>;
+}
+export default Superpro;

package/dist/mjs/staticModels/Superpro.js

@@ -0,0 +1,45 @@
+import { BlockchainConnector } from '../connectors/index.js';
+class Superpro {
+    static address;
+    /**
+     * Fetching address of contract by name
+     */
+    static getContractAddress() {
+        return this.address;
+    }
+    static async getPrimaryTokenAddress(contractInstance) {
+        const contract = contractInstance || BlockchainConnector.getInstance().getContract();
+        const tokens = await contract.getTokens();
+        // empty string will not be returned because
+        // tokens always have at least 1 main token
+        let primaryToken = '';
+        for (const token of tokens) {
+            if (token.tokenInfo.isPrimary) {
+                primaryToken = token.tokenInfo.tokenAddress;
+                break;
+            }
+        }
+        return primaryToken;
+    }
+    /**
+     * Fetching config parameter value by name
+     */
+    static getParam(name) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return contract.getConfigParam(name).then((value) => value.toString());
+    }
+    static isTokenExists(tokenContractAddress) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return contract.isTokenExists(tokenContractAddress);
+    }
+    static getTokens() {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return contract.getTokens();
+    }
+    static getTokenStorageRequestFee(tokenAddress) {
+        const contract = BlockchainConnector.getInstance().getContract();
+        return contract.getTokenStorageRequestFee(tokenAddress).then((value) => value.toString());
+    }
+}
+export default Superpro;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3VwZXJwcm8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RhdGljTW9kZWxzL1N1cGVycHJvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRzdELE1BQU0sUUFBUTtJQUNMLE1BQU0sQ0FBQyxPQUFPLENBQVM7SUFFOUI7O09BRUc7SUFDSSxNQUFNLENBQUMsa0JBQWtCO1FBQzlCLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRU0sTUFBTSxDQUFDLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxnQkFBc0I7UUFDL0QsTUFBTSxRQUFRLEdBQUcsZ0JBQWdCLElBQUksbUJBQW1CLENBQUMsV0FBVyxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDckYsTUFBTSxNQUFNLEdBQUcsTUFBTSxRQUFRLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDMUMsNENBQTRDO1FBQzVDLDJDQUEyQztRQUMzQyxJQUFJLFlBQVksR0FBRyxFQUFFLENBQUM7UUFDdEIsS0FBSyxNQUFNLEtBQUssSUFBSSxNQUFNLEVBQUUsQ0FBQztZQUMzQixJQUFJLEtBQUssQ0FBQyxTQUFTLENBQUMsU0FBUyxFQUFFLENBQUM7Z0JBQzlCLFlBQVksR0FBRyxLQUFLLENBQUMsU0FBUyxDQUFDLFlBQVksQ0FBQztnQkFDNUMsTUFBTTtZQUNSLENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxZQUFZLENBQUM7SUFDdEIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFlO1FBQ3BDLE1BQU0sUUFBUSxHQUFHLG1CQUFtQixDQUFDLFdBQVcsRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ2pFLE9BQU8sUUFBUSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7SUFFTSxNQUFNLENBQUMsYUFBYSxDQUFDLG9CQUE0QjtRQUN0RCxNQUFNLFFBQVEsR0FBRyxtQkFBbUIsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNqRSxPQUFPLFFBQVEsQ0FBQyxhQUFhLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUN0RCxDQUFDO0lBRU0sTUFBTSxDQUFDLFNBQVM7UUFDckIsTUFBTSxRQUFRLEdBQUcsbUJBQW1CLENBQUMsV0FBVyxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDakUsT0FBTyxRQUFRLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDOUIsQ0FBQztJQUVNLE1BQU0sQ0FBQyx5QkFBeUIsQ0FBQyxZQUFvQjtRQUMxRCxNQUFNLFFBQVEsR0FBRyxtQkFBbUIsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNqRSxPQUFPLFFBQVEsQ0FBQyx5QkFBeUIsQ0FBQyxZQUFZLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQzVGLENBQUM7Q0FDRjtBQUVELGVBQWUsUUFBUSxDQUFDIn0=

package/dist/mjs/staticModels/SuperproToken.d.ts

@@ -0,0 +1,113 @@
+import { TransactionOptions, BlockInfo, TokenAmount } from '../types/index.js';
+import { SuperProtocolToken } from '../contracts/SuperProtocolToken.js';
+import { TransactionReceipt } from 'ethers';
+declare class SuperproToken {
+    private static _addressHttps;
+    private static _addressWss;
+    private static contractHttps?;
+    private static readonly logger;
+    static get addressHttps(): string;
+    static set addressHttps(newAddress: string);
+    static createContract(newAddress: string): SuperProtocolToken;
+    static get addressWss(): string;
+    static set addressWss(newAddress: string);
+    /**
+     * Checks if contract has been initialized, if not - initialize contract
+     */
+    private static checkInit;
+    /**
+     * 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 getTransferEvents(params: {
+        filter?: {
+            from?: string;
+            to?: string;
+        };
+        fromBlock?: string | number | undefined;
+        toBlock?: string | number | undefined;
+    }, options?: {
+        concurrency?: number;
+        contract?: SuperProtocolToken;
+    }): Promise<{
+        from: string;
+        to: string;
+        value: bigint;
+        transactionHash: string;
+        blockNumber: bigint;
+        blockTimestamp: number;
+    }[]>;
+    /**
+     * Fetching balance of SuperProtocol tokens on address
+     */
+    static balanceOf(address: string, contract?: SuperProtocolToken): Promise<TokenAmount>;
+    /**
+     * Fetching allowance of SuperProtocol tokens on address
+     */
+    static allowance(from: string, to: string, contract?: SuperProtocolToken): Promise<TokenAmount>;
+    /**
+     * Fetching symbol of SuperProtocol tokens
+     */
+    static symbol(contract?: SuperProtocolToken): Promise<string>;
+    /**
+     * Fetching true if the address is whitelisted
+     */
+    static isWhitelisted(address: string): Promise<boolean>;
+    /**
+     * Fetching true if the whitelist is activated
+     */
+    static isWhitelistActivated(): Promise<boolean>;
+    /**
+     * 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 transfer(to: string, amount: TokenAmount, transactionOptions?: TransactionOptions): Promise<TransactionReceipt>;
+    /**
+     * 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 approve(address: string, amount: TokenAmount, transactionOptions?: TransactionOptions, contractInstance?: SuperProtocolToken): Promise<TransactionReceipt>;
+    /**
+     * Adds an address to the whitelist.
+     * @param address - address
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static addWhitelistAddress(address: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Removes an address from the whitelist.
+     * @param address - address
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static removeWhitelistAddress(address: string, transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Activates the whitelist.
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static activateWhitelist(transactionOptions?: TransactionOptions): Promise<void>;
+    /**
+     * Deactivates the whitelist.
+     * @param transactionOptions - object what contains alternative action account or gas limit (optional)
+     */
+    static deactivateWhitelist(transactionOptions?: TransactionOptions): Promise<void>;
+    static onTokenApprove(callback: onTokenApproveCallback, owner?: string, spender?: string): () => void;
+    static onTokenTransfer(callback: onTokenTransferCallback, from?: string, to?: string): () => void;
+    static onAddressAddedToWhitelist(callback: onAddressAddedToWhitelistCallback, address?: string): () => void;
+    static onAddressRemovedFromWhitelist(callback: onAddressRemovedFromWhitelistCallback, address?: string): () => void;
+    static onWhitelistActivated(callback: onWhitelistActivatedCallback): () => void;
+    static onWhitelistDeactivated(callback: onWhitelistDeactivatedCallback): () => void;
+    private static getContract;
+}
+export type onTokenApproveCallback = (owner: string, spender: string, value: TokenAmount, block?: BlockInfo) => void;
+export type onTokenTransferCallback = (from: string, to: string, value: TokenAmount, block?: BlockInfo) => void;
+export type onAddressAddedToWhitelistCallback = (address: string, block?: BlockInfo) => void;
+export type onAddressRemovedFromWhitelistCallback = (address: string, block?: BlockInfo) => void;
+export type onWhitelistActivatedCallback = (block?: BlockInfo) => void;
+export type onWhitelistDeactivatedCallback = (block?: BlockInfo) => void;
+export default SuperproToken;