@taquito/wallet-connect 24.3.0-beta.0 → 24.3.0-beta.2

package/dist/lib/taquito/src/subscribe/filters.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateFilter = exports.evaluateExpression = exports.evaluateOpFilter = exports.eventFilter = void 0;
+const errors_1 = require("./errors");
+const opHashFilter = (op, filter) => op.hash === filter.opHash;
+const sourceFilter = (x, filter) => {
+    switch (x.kind) {
+        case 'attestation':
+            return 'metadata' in x && x.metadata.delegate === filter.source;
+        case 'activate_account':
+            return 'metadata' in x && x.pkh === filter.source;
+        default:
+            return 'source' in x && x.source === filter.source;
+    }
+};
+const kindFilter = (x, filter) => 'kind' in x && x.kind === filter.kind;
+const destinationFilter = (x, filter) => {
+    switch (x.kind) {
+        case 'delegation':
+            return x.delegate === filter.destination;
+        case 'origination':
+            if ('metadata' in x &&
+                'operation_result' in x.metadata &&
+                'originated_contracts' in x.metadata.operation_result &&
+                Array.isArray(x.metadata.operation_result.originated_contracts)) {
+                return x.metadata.operation_result.originated_contracts.some((contract) => contract === filter.destination);
+            }
+            break;
+        case 'transaction':
+            return x.destination === filter.destination;
+        default:
+            return false;
+    }
+};
+const eventFilter = (result, address, tag, excludeFailedOperations) => {
+    if (result.kind !== 'event') {
+        return false;
+    }
+    if (tag && result.tag !== tag) {
+        return false;
+    }
+    if (address && result.source !== address) {
+        return false;
+    }
+    if (excludeFailedOperations && result.result.status !== 'applied') {
+        return false;
+    }
+    return true;
+};
+exports.eventFilter = eventFilter;
+const evaluateOpFilter = (op, filter) => {
+    if ('opHash' in filter) {
+        return opHashFilter(op, filter);
+    }
+    else if ('source' in filter) {
+        return sourceFilter(op, filter);
+    }
+    else if ('kind' in filter) {
+        return kindFilter(op, filter);
+    }
+    else if ('destination' in filter) {
+        return destinationFilter(op, filter);
+    }
+    return false;
+};
+exports.evaluateOpFilter = evaluateOpFilter;
+const evaluateExpression = (op, exp) => {
+    if (Array.isArray(exp.and)) {
+        return exp.and.every((x) => (0, exports.evaluateFilter)(op, x));
+    }
+    else if (Array.isArray(exp.or)) {
+        return exp.or.some((x) => (0, exports.evaluateFilter)(op, x));
+    }
+    else {
+        throw new errors_1.InvalidFilterExpressionError(exp);
+    }
+};
+exports.evaluateExpression = evaluateExpression;
+const evaluateFilter = (op, filter) => {
+    const filters = [];
+    if (!Array.isArray(filter)) {
+        filters.push(filter);
+    }
+    else {
+        filters.push(...filter);
+    }
+    return filters.every((filterOrExp) => {
+        if ('and' in filterOrExp || 'or' in filterOrExp) {
+            return (0, exports.evaluateExpression)(op, filterOrExp);
+        }
+        else {
+            return (0, exports.evaluateOpFilter)(op, filterOrExp);
+        }
+    });
+};
+exports.evaluateFilter = evaluateFilter;

package/dist/lib/taquito/src/subscribe/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/taquito/src/subscribe/observable-subscription.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableSubscription = exports.UnsupportedEventError = void 0;
+/* eslint-disable no-dupe-class-members */
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const errors_1 = require("./errors");
+var errors_2 = require("./errors");
+Object.defineProperty(exports, "UnsupportedEventError", { enumerable: true, get: function () { return errors_2.UnsupportedEventError; } });
+class ObservableSubscription {
+    constructor(obs, shouldRetry = false, operatorFunction = (0, operators_1.retry)()) {
+        this.shouldRetry = shouldRetry;
+        this.operatorFunction = operatorFunction;
+        this.errorListeners = [];
+        this.messageListeners = [];
+        this.closeListeners = [];
+        this.completed$ = new rxjs_1.Subject();
+        obs
+            .pipe((0, operators_1.takeUntil)(this.completed$), (0, operators_1.tap)((data) => {
+            this.call(this.messageListeners, data);
+        }, (error) => {
+            this.call(this.errorListeners, error);
+        }, () => {
+            this.call(this.closeListeners);
+        }), this.shouldRetry ? operatorFunction : (0, operators_1.tap)(), (0, operators_1.catchError)(() => rxjs_1.NEVER))
+            .subscribe();
+    }
+    call(listeners, value) {
+        for (const l of listeners) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                l(value);
+            }
+            catch (ex) {
+                console.error(ex);
+            }
+        }
+    }
+    remove(listeners, value) {
+        const idx = listeners.indexOf(value);
+        if (idx !== -1) {
+            listeners.splice(idx, 1);
+        }
+    }
+    on(type, cb) {
+        switch (type) {
+            case 'data':
+                this.messageListeners.push(cb);
+                break;
+            case 'error':
+                this.errorListeners.push(cb);
+                break;
+            case 'close':
+                this.closeListeners.push(cb);
+                break;
+            default:
+                throw new errors_1.UnsupportedEventError(type);
+        }
+    }
+    off(type, cb) {
+        switch (type) {
+            case 'data':
+                this.remove(this.messageListeners, cb);
+                break;
+            case 'error':
+                this.remove(this.errorListeners, cb);
+                break;
+            case 'close':
+                this.remove(this.closeListeners, cb);
+                break;
+            default:
+                throw new errors_1.UnsupportedEventError(type);
+        }
+    }
+    close() {
+        this.completed$.next();
+    }
+}
+exports.ObservableSubscription = ObservableSubscription;

package/dist/lib/taquito/src/subscribe/polling-subcribe-provider.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingSubscribeProvider = exports.defaultConfigStreamer = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const filters_1 = require("./filters");
+const observable_subscription_1 = require("./observable-subscription");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+exports.defaultConfigStreamer = {
+    shouldObservableSubscriptionRetry: false,
+    observableSubscriptionRetryFunction: (0, operators_1.retry)(),
+};
+const getLastBlock = (context) => {
+    return (0, rxjs_1.from)(context.rpc.getBlock()).pipe((0, operators_1.first)());
+};
+const applyFilter = (filter) => (0, operators_1.concatMap)((block) => {
+    return new rxjs_1.Observable((sub) => {
+        for (const ops of block.operations) {
+            for (const op of ops) {
+                for (const content of op.contents) {
+                    if ((0, filters_1.evaluateFilter)({ hash: op.hash, ...content }, filter)) {
+                        sub.next({ hash: op.hash, ...content });
+                    }
+                }
+            }
+        }
+        sub.complete();
+    });
+});
+const applyEventFilter = (filter) => (0, operators_1.concatMap)((block) => {
+    return new rxjs_1.Observable((sub) => {
+        for (const ops of block.operations) {
+            for (const op of ops) {
+                for (const content of op.contents) {
+                    const tx = content;
+                    const internalOpResults = tx.metadata.internal_operation_results;
+                    if (internalOpResults) {
+                        for (const event of internalOpResults) {
+                            if ((0, filters_1.eventFilter)(event, filter?.address, filter?.tag, filter?.excludeFailedOperations)) {
+                                sub.next({
+                                    opHash: op.hash,
+                                    blockHash: block.hash,
+                                    level: block.header.level,
+                                    ...event,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        sub.complete();
+    });
+});
+class PollingSubscribeProvider {
+    constructor(context, config = {}) {
+        this.context = context;
+        this._config$ = new rxjs_1.BehaviorSubject({
+            ...exports.defaultConfigStreamer,
+            ...config,
+        });
+        this.timer$ = this._config$.pipe((0, operators_1.map)((x) => x?.pollingIntervalMilliseconds), (0, operators_1.switchMap)((pollingIntervalMilliseconds) => {
+            if (!pollingIntervalMilliseconds) {
+                return (0, rxjs_1.from)(this.getConfirmationPollingInterval()).pipe((0, operators_1.switchMap)((interval) => {
+                    return (0, rxjs_1.timer)(0, interval);
+                }));
+            }
+            else {
+                return (0, rxjs_1.timer)(0, pollingIntervalMilliseconds);
+            }
+        }));
+        this.newBlock$ = this.timer$.pipe((0, operators_1.exhaustMap)(() => getLastBlock(this.context)), (0, operators_1.distinctUntilKeyChanged)('hash'), (0, operators_1.share)({
+            resetOnError: false,
+            resetOnComplete: false,
+            resetOnRefCountZero: true,
+        }));
+    }
+    get config() {
+        return this._config$.getValue();
+    }
+    async getConfirmationPollingInterval() {
+        if (!this.config.pollingIntervalMilliseconds) {
+            const defaultIntervalTestnetsMainnet = 5000;
+            const minimumPollingInterval = 700;
+            try {
+                const constants = await this.context.readProvider.getProtocolConstants('head');
+                const blockTime = constants.minimal_block_delay
+                    ? constants.minimal_block_delay.multipliedBy(1000)
+                    : new bignumber_js_1.default(defaultIntervalTestnetsMainnet);
+                const confirmationPollingInterval = blockTime.dividedBy(3);
+                this.config.pollingIntervalMilliseconds =
+                    confirmationPollingInterval.toNumber() === 0
+                        ? minimumPollingInterval
+                        : Math.max(confirmationPollingInterval.toNumber(), minimumPollingInterval);
+            }
+            catch (exception) {
+                return defaultIntervalTestnetsMainnet;
+            }
+        }
+        return this.config.pollingIntervalMilliseconds;
+    }
+    subscribeBlock(_filter) {
+        return new observable_subscription_1.ObservableSubscription(this.newBlock$, this.config.shouldObservableSubscriptionRetry, this.config.observableSubscriptionRetryFunction);
+    }
+    subscribe(_filter) {
+        return new observable_subscription_1.ObservableSubscription(this.newBlock$.pipe((0, operators_1.map)((x) => x?.hash)), this.config.shouldObservableSubscriptionRetry, this.config.observableSubscriptionRetryFunction);
+    }
+    subscribeOperation(filter) {
+        return new observable_subscription_1.ObservableSubscription(this.newBlock$.pipe(applyFilter(filter)), this.config.shouldObservableSubscriptionRetry, this.config.observableSubscriptionRetryFunction);
+    }
+    subscribeEvent(eventFilter) {
+        return new observable_subscription_1.ObservableSubscription(this.newBlock$.pipe(applyEventFilter(eventFilter)), this.config.shouldObservableSubscriptionRetry, this.config.observableSubscriptionRetryFunction);
+    }
+}
+exports.PollingSubscribeProvider = PollingSubscribeProvider;