@taquito/taquito 24.2.0 → 24.3.0-beta.0

package/dist/lib/read-provider/rpc-read-adapter.js

@@ -1,224 +1,179 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcReadAdapter = void 0;
 /**
- * @description Converts calls from TzReadProvider into calls to the wrapped RpcClient in a format it can understand.
+ * Converts calls from TzReadProvider into calls to the wrapped RpcClient in a format it can understand.
  */
 class RpcReadAdapter {
     constructor(rpc) {
         this.rpc = rpc;
     }
     /**
-     * @description The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'spendable' RPC.
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'spendable' RPC.
      * @param address address from which we want to retrieve the spendable balance
      * @param block from which we want to retrieve the balance
      * @returns the balance in mutez
      */
-    getBalance(address, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getBalance(address, { block: String(block) });
-        });
+    async getBalance(address, block) {
+        return this.rpc.getBalance(address, { block: String(block) });
     }
     /**
-     * @description The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'balance' RPC.
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'balance' RPC.
      * @param address address from which we want to retrieve the spendable balance
      * @param block from which we want to retrieve the balance
      * @returns the balance in mutez
      */
-    getSpendable(address, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getSpendable(address, { block: String(block) });
-        });
+    async getSpendable(address, block) {
+        return this.rpc.getSpendable(address, { block: String(block) });
     }
     /**
-     * @description Access the delegate of a contract, if any.
+     * Access the delegate of a contract, if any.
      * @param address contract address from which we want to retrieve the delegate (baker)
      * @param block from which we want to retrieve the delegate
      * @returns the public key hash of the delegate or null if no delegate
      */
-    getDelegate(address, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getDelegate(address, { block: String(block) });
-        });
+    async getDelegate(address, block) {
+        return this.rpc.getDelegate(address, { block: String(block) });
     }
     /**
-     * @description Access the next protocol hash
+     * Access the next protocol hash
      * @param block from which we want to retrieve the next protocol hash
      */
-    getNextProtocol(block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const protocols = yield this.rpc.getProtocols({ block: String(block) });
-            return protocols.next_protocol;
-        });
+    async getNextProtocol(block) {
+        const protocols = await this.rpc.getProtocols({ block: String(block) });
+        return protocols.next_protocol;
     }
     /**
-     * @description Access protocol constants used in Taquito
+     * Access protocol constants used in Taquito
      * @param block from which we want to retrieve the constants
      */
-    getProtocolConstants(block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { time_between_blocks, minimal_block_delay, hard_gas_limit_per_operation, hard_gas_limit_per_block, hard_storage_limit_per_operation, cost_per_byte, smart_rollup_origination_size, } = yield this.rpc.getConstants({ block: String(block) });
-            return {
-                time_between_blocks,
-                minimal_block_delay,
-                hard_gas_limit_per_operation,
-                hard_gas_limit_per_block,
-                hard_storage_limit_per_operation,
-                cost_per_byte,
-                smart_rollup_origination_size,
-            };
-        });
+    async getProtocolConstants(block) {
+        const { time_between_blocks, minimal_block_delay, hard_gas_limit_per_operation, hard_gas_limit_per_block, hard_storage_limit_per_operation, cost_per_byte, smart_rollup_origination_size, } = await this.rpc.getConstants({ block: String(block) });
+        return {
+            time_between_blocks,
+            minimal_block_delay,
+            hard_gas_limit_per_operation,
+            hard_gas_limit_per_block,
+            hard_storage_limit_per_operation,
+            cost_per_byte,
+            smart_rollup_origination_size,
+        };
     }
     /**
-     * @description Access the script (code and storage) of a smart contract
+     * Access the script (code and storage) of a smart contract
      * @param contract contract address from which we want to retrieve the script
      * @param block from which we want to retrieve the storage value
      * @returns Note: The code must be in the JSON format and not contain global constant
      */
-    getScript(contract, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { script } = yield this.rpc.getContract(contract, { block: String(block) });
-            return script;
-        });
+    async getScript(contract, block) {
+        const { script } = await this.rpc.getContract(contract, { block: String(block) });
+        return script;
     }
     /**
-     * @description Access the storage value of a contract
+     * Access the storage value of a contract
      * @param contract contract address from which we want to retrieve the storage
      * @param block from which we want to retrieve the storage value
      */
-    getStorage(contract, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getStorage(contract, { block: String(block) });
-        });
+    async getStorage(contract, block) {
+        return this.rpc.getStorage(contract, { block: String(block) });
     }
     /**
-     * @description Access the block hash
+     * Access the block hash
      */
-    getBlockHash(block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { hash } = yield this.rpc.getBlockHeader({ block: String(block) });
-            return hash;
-        });
+    async getBlockHash(block) {
+        const { hash } = await this.rpc.getBlockHeader({ block: String(block) });
+        return hash;
     }
     /**
-     * @description Access the block level
+     * Access the block level
      */
-    getBlockLevel(block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { level } = yield this.rpc.getBlockHeader({ block: String(block) });
-            return level;
-        });
+    async getBlockLevel(block) {
+        const { level } = await this.rpc.getBlockHeader({ block: String(block) });
+        return level;
     }
     /**
-     * @description Access the counter of an address
+     * Access the counter of an address
      * @param pkh from which we want to retrieve the counter
      * @param block from which we want to retrieve the counter
      */
-    getCounter(pkh, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { counter } = yield this.rpc.getContract(pkh, { block: String(block) });
-            return counter || '0';
-        });
+    async getCounter(pkh, block) {
+        const { counter } = await this.rpc.getContract(pkh, { block: String(block) });
+        return counter || '0';
     }
     /**
-     * @description Access the timestamp of a block
+     * Access the timestamp of a block
      * @param block from which we want to retrieve the timestamp
      * @returns date ISO format zero UTC offset ("2022-01-19T22:37:07Z")
      */
-    getBlockTimestamp(block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { timestamp } = yield this.rpc.getBlockHeader({ block: String(block) });
-            return timestamp;
-        });
+    async getBlockTimestamp(block) {
+        const { timestamp } = await this.rpc.getBlockHeader({ block: String(block) });
+        return timestamp;
     }
     /**
-     * @description Access the value associated with a key in a big map.
+     * Access the value associated with a key in a big map.
      * @param bigMapQuery Big Map ID and Expression hash to query (A b58check encoded Blake2b hash of the expression)
      * @param block from which we want to retrieve the big map value
      */
-    getBigMapValue(bigMapQuery, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getBigMapExpr(bigMapQuery.id, bigMapQuery.expr, {
-                block: String(block),
-            });
+    async getBigMapValue(bigMapQuery, block) {
+        return this.rpc.getBigMapExpr(bigMapQuery.id, bigMapQuery.expr, {
+            block: String(block),
         });
     }
     /**
-     * @description Access the value associated with a sapling state ID.
-     * @param id Sapling state ID
+     * Access the value associated with a sapling state ID.
+     * @param saplingStateQuery Sapling state ID query
      * @param block from which we want to retrieve the sapling state
      */
-    getSaplingDiffById(saplingStateQuery, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getSaplingDiffById(saplingStateQuery.id, { block: String(block) });
-        });
+    async getSaplingDiffById(saplingStateQuery, block) {
+        return this.rpc.getSaplingDiffById(saplingStateQuery.id, { block: String(block) });
     }
     /**
-     * @description Access the sapling state of a smart contract.
+     * Access the sapling state of a smart contract.
      * @param contractAddress The address of the smart contract
      * @param block The block you want to retrieve the sapling state from
      */
-    getSaplingDiffByContract(contractAddress, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getSaplingDiffByContract(contractAddress, { block: String(block) });
-        });
+    async getSaplingDiffByContract(contractAddress, block) {
+        return this.rpc.getSaplingDiffByContract(contractAddress, { block: String(block) });
     }
     /**
-     * @description Return the list of entrypoints of the contract
+     * Return the list of entrypoints of the contract
      * @param contract address of the contract we want to get the entrypoints of
      */
-    getEntrypoints(contract) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getEntrypoints(contract);
-        });
+    async getEntrypoints(contract) {
+        return this.rpc.getEntrypoints(contract);
     }
     /**
-     * @description Access the chain id
+     * Access the chain id
      */
-    getChainId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getChainId();
-        });
+    async getChainId() {
+        return this.rpc.getChainId();
     }
     /**
-     * @description Indicate if an account is revealed
+     * Indicate if an account is revealed
      * @param publicKeyHash of the account
      * @param block from which we want to know if the account is revealed
      */
-    isAccountRevealed(publicKeyHash, block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const manager = yield this.rpc.getManagerKey(publicKeyHash, { block: String(block) });
-            const haveManager = manager && typeof manager === 'object' ? !!manager.key : !!manager;
-            return haveManager;
-        });
+    async isAccountRevealed(publicKeyHash, block) {
+        const manager = await this.rpc.getManagerKey(publicKeyHash, { block: String(block) });
+        const haveManager = manager && typeof manager === 'object' ? !!manager.key : !!manager;
+        return haveManager;
     }
     /**
-     * @description Return all the information about a block
+     * Return all the information about a block
      * @param block from which we want to retrieve the information
      */
-    getBlock(block) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rpc.getBlock({ block: String(block) });
-        });
+    async getBlock(block) {
+        return this.rpc.getBlock({ block: String(block) });
     }
     /**
-     * @description Return a list of the ancestors of the given block which, if referred to as the branch in an operation header, are recent enough for that operation to be included in the current block.
+     * Return a list of the ancestors of the given block which, if referred to as the branch in an operation header, are recent enough for that operation to be included in the current block.
      * @param block from which we want to retrieve the information
      */
     getLiveBlocks(block) {
         return this.rpc.getLiveBlocks({ block: String(block) });
     }
     /**
-     * @description Returns the cycle at which the launch of the Adaptive Issuance feature is set to happen. A result of null means that the feature is not yet set to launch.
+     * Returns the cycle at which the launch of the Adaptive Issuance feature is set to happen. A result of null means that the feature is not yet set to launch.
      * @param block from which we want to retrieve the information
      */
     getAdaptiveIssuanceLaunchCycle(block) {

package/dist/lib/signer/errors.js

@@ -4,7 +4,7 @@ exports.UnconfiguredSignerError = void 0;
 const core_1 = require("@taquito/core");
 /**
  *  @category Error
- *  @description Error that indicates no signer has been configured in the TezosToolkit instance
+ *  Error that indicates no signer has been configured in the TezosToolkit instance
  */
 class UnconfiguredSignerError extends core_1.TezosToolkitConfigError {
     constructor() {

package/dist/lib/signer/noop.js

@@ -1,40 +1,23 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoopSigner = void 0;
 const errors_1 = require("./errors");
 /**
- * @description Default signer implementation which does nothing and produce invalid signature
+ * Default signer implementation which does nothing and produce invalid signature
  * @throw {@link UnconfiguredSignerError}
  */
 class NoopSigner {
-    publicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new errors_1.UnconfiguredSignerError();
-        });
+    async publicKey() {
+        throw new errors_1.UnconfiguredSignerError();
     }
-    publicKeyHash() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new errors_1.UnconfiguredSignerError();
-        });
+    async publicKeyHash() {
+        throw new errors_1.UnconfiguredSignerError();
     }
-    secretKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new errors_1.UnconfiguredSignerError();
-        });
+    async secretKey() {
+        throw new errors_1.UnconfiguredSignerError();
     }
-    sign(_bytes, _watermark) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new errors_1.UnconfiguredSignerError();
-        });
+    async sign(_bytes, _watermark) {
+        throw new errors_1.UnconfiguredSignerError();
     }
 }
 exports.NoopSigner = NoopSigner;

package/dist/lib/subscribe/errors.js

@@ -4,7 +4,7 @@ exports.InvalidFilterExpressionError = exports.UnsupportedEventError = void 0;
 const core_1 = require("@taquito/core");
 /**
  *  @category Error
- *  @description Error that indicates an unsupported event being passed or used
+ *  Error that indicates an unsupported event being passed or used
  */
 class UnsupportedEventError extends core_1.ParameterValidationError {
     constructor(type) {
@@ -17,7 +17,7 @@ class UnsupportedEventError extends core_1.ParameterValidationError {
 exports.UnsupportedEventError = UnsupportedEventError;
 /**
  *  @category Error
- *  @description Error that indicates an invalid filter expression being passed or used
+ *  Error that indicates an invalid filter expression being passed or used
  */
 class InvalidFilterExpressionError extends core_1.ParameterValidationError {
     constructor(invalidExpression) {

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PollingSubscribeProvider = exports.defaultConfigStreamer = void 0;
 const rxjs_1 = require("rxjs");
@@ -27,8 +18,8 @@ const applyFilter = (filter) => (0, operators_1.concatMap)((block) => {
         for (const ops of block.operations) {
             for (const op of ops) {
                 for (const content of op.contents) {
-                    if ((0, filters_1.evaluateFilter)(Object.assign({ hash: op.hash }, content), filter)) {
-                        sub.next(Object.assign({ hash: op.hash }, content));
+                    if ((0, filters_1.evaluateFilter)({ hash: op.hash, ...content }, filter)) {
+                        sub.next({ hash: op.hash, ...content });
                     }
                 }
             }
@@ -45,8 +36,13 @@ const applyEventFilter = (filter) => (0, operators_1.concatMap)((block) => {
                     const internalOpResults = tx.metadata.internal_operation_results;
                     if (internalOpResults) {
                         for (const event of internalOpResults) {
-                            if ((0, filters_1.eventFilter)(event, filter === null || filter === void 0 ? void 0 : filter.address, filter === null || filter === void 0 ? void 0 : filter.tag, filter === null || filter === void 0 ? void 0 : filter.excludeFailedOperations)) {
-                                sub.next(Object.assign({ opHash: op.hash, blockHash: block.hash, level: block.header.level }, event));
+                            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,
+                                });
                             }
                         }
                     }
@@ -59,8 +55,11 @@ const applyEventFilter = (filter) => (0, operators_1.concatMap)((block) => {
 class PollingSubscribeProvider {
     constructor(context, config = {}) {
         this.context = context;
-        this._config$ = new rxjs_1.BehaviorSubject(Object.assign(Object.assign({}, exports.defaultConfigStreamer), config));
-        this.timer$ = this._config$.pipe((0, operators_1.map)((x) => x === null || x === void 0 ? void 0 : x.pollingIntervalMilliseconds), (0, operators_1.switchMap)((pollingIntervalMilliseconds) => {
+        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);
@@ -70,7 +69,7 @@ class PollingSubscribeProvider {
                 return (0, rxjs_1.timer)(0, pollingIntervalMilliseconds);
             }
         }));
-        this.newBlock$ = this.timer$.pipe((0, operators_1.switchMap)(() => getLastBlock(this.context)), (0, operators_1.distinctUntilKeyChanged)('hash'), (0, operators_1.share)({
+        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,
@@ -79,34 +78,32 @@ class PollingSubscribeProvider {
     get config() {
         return this._config$.getValue();
     }
-    getConfirmationPollingInterval() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config.pollingIntervalMilliseconds) {
-                const defaultIntervalTestnetsMainnet = 5000;
-                const minimumPollingInterval = 700;
-                try {
-                    const constants = yield 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;
-                }
+    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);
             }
-            return this.config.pollingIntervalMilliseconds;
-        });
+            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 === null || x === void 0 ? void 0 : x.hash)), this.config.shouldObservableSubscriptionRetry, this.config.observableSubscriptionRetryFunction);
+        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);