@taquito/taquito 11.2.0 → 12.0.0-beta-RC.0

package/dist/taquito.es6.js

@@ -1,13 +1,14 @@
 import { OpKind, RpcClient } from '@taquito/rpc';
 export { OpKind } from '@taquito/rpc';
-import { ReplaySubject, defer, timer, from, of, EMPTY, combineLatest, throwError, range, concat, BehaviorSubject, Subject, NEVER, Observable } from 'rxjs';
-import { first, tap, map, switchMap, mapTo, switchMapTo, filter, shareReplay, catchError, distinctUntilChanged, takeWhile, distinctUntilKeyChanged, timeoutWith, startWith, concatMap, retry, takeUntil, publish, refCount, pluck } from 'rxjs/operators';
+import { Observable, ReplaySubject, defer, throwError, of, EMPTY, combineLatest, from, range, concat, Subject, NEVER, BehaviorSubject, timer } from 'rxjs';
+import { switchMap, timeoutWith, shareReplay, map, filter, first, catchError, tap, distinctUntilChanged, takeWhile, startWith, concatMap, retry, takeUntil, pluck, distinctUntilKeyChanged, publish, refCount } from 'rxjs/operators';
 import { Schema, ParameterSchema, ViewSchema, MichelsonMap } from '@taquito/michelson-encoder';
 export { MichelsonMap, UnitValue } from '@taquito/michelson-encoder';
 import BigNumber from 'bignumber.js';
-import { validateOperation, ValidationResult, InvalidOperationHashError, validateAddress, InvalidAddressError, validateKeyHash, InvalidKeyHashError, validateContractAddress, InvalidContractAddressError, encodeExpr } from '@taquito/utils';
+import { validateOperation, ValidationResult, InvalidOperationHashError, validateAddress, InvalidAddressError, validateKeyHash, InvalidKeyHashError, validateContractAddress, InvalidContractAddressError, validateChain, encodeExpr } from '@taquito/utils';
 import { HttpResponseError, STATUS_CODE } from '@taquito/http-utils';
 import { Parser, packDataBytes } from '@taquito/michel-codec';
+import { LocalForger } from '@taquito/local-forging';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -46,15 +47,6 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-class RpcForger {
-    constructor(context) {
-        this.context = context;
-    }
-    forge({ branch, contents }) {
-        return this.context.rpc.forgeOperations({ branch, contents });
-    }
-}
-
 class RpcInjector {
     constructor(context) {
         this.context = context;
@@ -96,6 +88,23 @@ class NoopSigner {
     }
 }
 
+function createObservableFromSubscription(sub) {
+    return new Observable((subscriber) => {
+        sub.on('data', (data) => {
+            subscriber.next(data);
+        });
+        sub.on('error', (error) => {
+            subscriber.error(error);
+        });
+        sub.on('close', () => {
+            subscriber.complete();
+        });
+        return () => {
+            sub.close();
+        };
+    });
+}
+
 var DEFAULT_GAS_LIMIT;
 (function (DEFAULT_GAS_LIMIT) {
     DEFAULT_GAS_LIMIT[DEFAULT_GAS_LIMIT["DELEGATION"] = 10600] = "DELEGATION";
@@ -145,18 +154,6 @@ const protocols = {
     '013': [Protocols.Psithaca2],
     '014': [Protocols.ProtoALpha],
 };
-var DefaultLambdaAddresses;
-(function (DefaultLambdaAddresses) {
-    DefaultLambdaAddresses["MAINNET"] = "KT1CPuTzwC7h7uLXd5WQmpMFso1HxrLBUtpE";
-    DefaultLambdaAddresses["CARTHAGENET"] = "KT1VAy1o1FGiXYfD3YT7x7k5eF5HSHhmc1u6";
-    DefaultLambdaAddresses["DELPHINET"] = "KT19abMFs3haqyKYwqdLjK9GbtofryZLvpiK";
-    DefaultLambdaAddresses["EDONET"] = "KT1A64nVZDccAHGAsf1ZyVajXZcbiwjV3SnN";
-    DefaultLambdaAddresses["FLORENCENET"] = "KT1KCe3YqGnudsiCWb5twbe2DH5T3EMdLpSE";
-    DefaultLambdaAddresses["GRANADANET"] = "KT1BCun2vsA4GBQvsKAuGD5x873MfW2jsN9z";
-    DefaultLambdaAddresses["HANGZHOUNET"] = "KT1PWtBAr1hjK9M9s9oZNZFbfzPdkkD6PSJR";
-    DefaultLambdaAddresses["ITHACANET"] = "KT1CsEGfRHWeuUQFh9LfVFLVMbm7DFBuHPPU";
-    DefaultLambdaAddresses["ITHACANET2"] = "KT1H2a5vGkMLFGBPMs6oRRJshCvYeXSBSadn";
-})(DefaultLambdaAddresses || (DefaultLambdaAddresses = {}));
 var ChainIds;
 (function (ChainIds) {
     ChainIds["MAINNET"] = "NetXdQprcVkpaWU";
@@ -489,35 +486,11 @@ class Operation {
         this.results = results;
         this.context = context;
         this._pollingConfig$ = new ReplaySubject(1);
-        this._currentHeadPromise = undefined;
-        // Caching the current head for one second
-        this.currentHead$ = defer(() => {
-            if (!this._currentHeadPromise) {
-                this._currentHeadPromise = this.context.rpc.getBlock();
-                timer(1000)
-                    .pipe(first())
-                    .subscribe(() => {
-                    this._currentHeadPromise = undefined;
-                });
-            }
-            return from(this._currentHeadPromise);
-        });
-        // Polling observable that emit until timeout is reached
-        this.polling$ = defer(() => this._pollingConfig$.pipe(tap(({ timeout, interval }) => {
-            if (timeout <= 0) {
-                throw new Error('Timeout must be more than 0');
-            }
-            if (interval <= 0) {
-                throw new Error('Interval must be more than 0');
-            }
-        }), map((config) => (Object.assign(Object.assign({}, config), { timeoutAt: Math.ceil(config.timeout / config.interval) + 1, count: 0 }))), switchMap((config) => timer(0, config.interval * 1000).pipe(mapTo(config))), tap((config) => {
-            config.count++;
-            if (config.count > config.timeoutAt) {
-                throw new Error(`Confirmation polling timed out`);
-            }
-        })));
+        this.currentHead$ = this._pollingConfig$.pipe(switchMap((config) => {
+            return defer(() => createObservableFromSubscription(this.context.stream.subscribeBlock('head'))).pipe(timeoutWith(config.timeout * 1000, throwError(new Error('Confirmation polling timed out'))));
+        }), shareReplay({ refCount: true }));
         // Observable that emit once operation is seen in a block
-        this.confirmed$ = this.polling$.pipe(switchMapTo(this.currentHead$), map((head) => {
+        this.confirmed$ = this.currentHead$.pipe(map((head) => {
             for (let i = 3; i >= 0; i--) {
                 head.operations[i].forEach((op) => {
                     if (op.hash === this.hash) {
@@ -533,9 +506,11 @@ class Operation {
         if (validateOperation(this.hash) !== ValidationResult.VALID) {
             throw new InvalidOperationHashError(`Invalid Operation Hash: ${this.hash}`);
         }
-        this.confirmed$.pipe(first(), catchError(() => {
+        this.confirmed$
+            .pipe(first(), catchError(() => {
             return of(EMPTY);
-        })).subscribe();
+        }))
+            .subscribe();
     }
     get includedInBlock() {
         return this._foundAt;
@@ -565,26 +540,21 @@ class Operation {
     /**
      *
      * @param confirmations [0] Number of confirmation to wait for
-     * @param interval [10] Polling interval
      * @param timeout [180] Timeout
      */
-    confirmation(confirmations, interval, timeout) {
+    confirmation(confirmations, timeout) {
         return __awaiter(this, void 0, void 0, function* () {
             if (typeof confirmations !== 'undefined' && confirmations < 1) {
                 throw new Error('Confirmation count must be at least 1');
             }
-            const confirmationPollingIntervalSecond = this.context.config.confirmationPollingIntervalSecond !== undefined
-                ? this.context.config.confirmationPollingIntervalSecond
-                : yield this.context.getConfirmationPollingInterval();
             const { defaultConfirmationCount, confirmationPollingTimeoutSecond } = this.context.config;
             this._pollingConfig$.next({
-                interval: interval || confirmationPollingIntervalSecond,
                 timeout: timeout || confirmationPollingTimeoutSecond,
             });
             const conf = confirmations !== undefined ? confirmations : defaultConfirmationCount;
             return new Promise((resolve, reject) => {
                 this.confirmed$
-                    .pipe(switchMap(() => this.polling$), switchMap(() => this.currentHead$), filter((head) => head.header.level - this._foundAt >= conf - 1), first())
+                    .pipe(switchMap(() => this.currentHead$), filter((head) => head.header.level - this._foundAt >= conf - 1), first())
                     .subscribe((_) => {
                     resolve(this._foundAt + (conf - 1));
                 }, reject);
@@ -655,9 +625,7 @@ class OperationEmitter {
     }
     isAccountRevealRequired(publicKeyHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const manager = yield this.rpc.getManagerKey(publicKeyHash);
-            const haveManager = manager && typeof manager === 'object' ? !!manager.key : !!manager;
-            return !haveManager;
+            return !(yield this.context.readProvider.isAccountRevealed(publicKeyHash, 'head'));
         });
     }
     isRevealRequiredForOpType(op) {
@@ -670,12 +638,12 @@ class OperationEmitter {
         return opRequireReveal;
     }
     // Originally from sotez (Copyright (c) 2018 Andrew Kishino)
-    prepareOperation({ operation, source, }) {
+    prepareOperation({ operation, source }, pkh) {
         return __awaiter(this, void 0, void 0, function* () {
             const counters = {};
             let ops = [];
-            const blockHeaderPromise = this.rpc.getBlockHeader({ block: 'head~2' });
-            const blockMetaPromise = this.rpc.getBlockMetadata();
+            const blockHashPromise = this.context.readProvider.getBlockHash('head~2');
+            const blockProtoPromise = this.context.readProvider.getNextProtocol('head');
             if (Array.isArray(operation)) {
                 ops = [...operation];
             }
@@ -683,27 +651,19 @@ class OperationEmitter {
                 ops = [operation];
             }
             // Implicit account who emit the operation
-            const publicKeyHash = yield this.signer.publicKeyHash();
+            const publicKeyHash = pkh ? pkh : yield this.signer.publicKeyHash();
             let counterPromise = Promise.resolve(undefined);
             for (let i = 0; i < ops.length; i++) {
                 if (isOpRequireReveal(ops[i]) || ops[i].kind === 'reveal') {
-                    const { counter } = yield this.rpc.getContract(publicKeyHash);
-                    counterPromise = Promise.resolve(counter);
+                    counterPromise = this.context.readProvider.getCounter(publicKeyHash, 'head');
                     break;
                 }
             }
-            const [header, metadata, headCounter] = yield Promise.all([
-                blockHeaderPromise,
-                blockMetaPromise,
+            const [hash, protocol, headCounter] = yield Promise.all([
+                blockHashPromise,
+                blockProtoPromise,
                 counterPromise,
             ]);
-            if (!header) {
-                throw new Error('Unable to fetch latest block header');
-            }
-            if (!metadata) {
-                throw new Error('Unable to fetch latest metadata');
-            }
-            const head = header;
             const counter = parseInt(headCounter || '0', 10);
             if (!counters[publicKeyHash] || counters[publicKeyHash] < counter) {
                 counters[publicKeyHash] = counter;
@@ -745,12 +705,10 @@ class OperationEmitter {
                         throw new Error('Unsupported operation');
                 }
             });
-            const branch = head.hash;
             const contents = constructOps(ops);
-            const protocol = metadata.next_protocol;
             return {
                 opOb: {
-                    branch,
+                    branch: hash,
                     contents,
                     protocol,
                 },
@@ -1135,7 +1093,7 @@ class WalletOperation {
             if (!this._included) {
                 return 0;
             }
-            return combineLatest([this._includedInBlock, from(this.context.rpc.getBlock())])
+            return combineLatest([this._includedInBlock, from(this.context.readProvider.getBlock('head'))])
                 .pipe(map(([foundAtBlock, head]) => {
                 return head.header.level - foundAtBlock.header.level + 1;
             }), first())
@@ -1148,15 +1106,15 @@ class WalletOperation {
             if (!this._included) {
                 return true;
             }
-            const tipBlockHeader = yield this.context.rpc.getBlockHeader({ block: tipBlockIdentifier });
+            const tipBlockHeaderLevel = yield this.context.readProvider.getBlockLevel(tipBlockIdentifier);
             const inclusionBlock = yield this._includedInBlock.pipe(first()).toPromise();
-            const levelDiff = tipBlockHeader.level - inclusionBlock.header.level;
+            const levelDiff = tipBlockHeaderLevel - inclusionBlock.header.level;
             // Block produced before the operation is included are assumed to be part of the current branch
             if (levelDiff <= 0) {
                 return true;
             }
             const tipBlockLevel = Math.min(inclusionBlock.header.level + levelDiff, inclusionBlock.header.level + MAX_BRANCH_ANCESTORS);
-            const blocks = new Set(yield this.context.rpc.getLiveBlocks({ block: String(tipBlockLevel) }));
+            const blocks = new Set(yield this.context.readProvider.getLiveBlocks(tipBlockLevel));
             return blocks.has(inclusionBlock.hash);
         });
     }
@@ -1231,13 +1189,13 @@ class DelegationWalletOperation extends WalletOperation {
     revealOperation() {
         return __awaiter(this, void 0, void 0, function* () {
             const operationResult = yield this.operationResults();
-            return operationResult.find(x => x.kind === OpKind.REVEAL);
+            return operationResult.find((x) => x.kind === OpKind.REVEAL);
         });
     }
     delegationOperation() {
         return __awaiter(this, void 0, void 0, function* () {
             const operationResult = yield this.operationResults();
-            return operationResult.find(x => x.kind === OpKind.DELEGATION);
+            return operationResult.find((x) => x.kind === OpKind.DELEGATION);
         });
     }
     status() {
@@ -1325,21 +1283,8 @@ class TransactionWalletOperation extends WalletOperation {
     }
 }
 
-const cacheUntil = (cacheUntilObs) => (source) => {
-    let subject = null;
-    return defer(() => {
-        if (!subject) {
-            subject = new ReplaySubject();
-            source.pipe(first()).subscribe(subject);
-            cacheUntilObs.pipe(first()).subscribe(() => {
-                subject = null;
-            });
-        }
-        return subject;
-    });
-};
-const createNewPollingBasedHeadObservable = (pollingTimer, sharedHeadOb, context, scheduler) => {
-    return pollingTimer.pipe(switchMap(() => sharedHeadOb), distinctUntilKeyChanged('hash'), timeoutWith(context.config.confirmationPollingTimeoutSecond * 1000, throwError(new Error('Confirmation polling timed out')), scheduler), shareReplay({
+const createNewPollingBasedHeadObservable = (sharedHeadOb, context, scheduler) => {
+    return sharedHeadOb.pipe(timeoutWith(context.config.confirmationPollingTimeoutSecond * 1000, throwError(new Error('Confirmation polling timed out')), scheduler), shareReplay({
         refCount: true,
         scheduler,
     }));
@@ -1348,23 +1293,22 @@ class OperationFactory {
     constructor(context) {
         this.context = context;
         // Cache the last block for one second across all operations
-        this.sharedHeadObs = defer(() => from(this.context.rpc.getBlock())).pipe(cacheUntil(timer(0, 1000)));
+        this.sharedHeadObs = defer(() => {
+            return createObservableFromSubscription(this.context.stream.subscribeBlock('head'));
+        });
     }
     createNewHeadObservable() {
         return __awaiter(this, void 0, void 0, function* () {
-            const confirmationPollingIntervalSecond = this.context.config.confirmationPollingIntervalSecond !== undefined
-                ? this.context.config.confirmationPollingIntervalSecond
-                : yield this.context.getConfirmationPollingInterval();
-            return createNewPollingBasedHeadObservable(timer(0, confirmationPollingIntervalSecond * 1000), this.sharedHeadObs, this.context);
+            return createNewPollingBasedHeadObservable(this.sharedHeadObs, this.context);
         });
     }
     createPastBlockWalker(startBlock, count = 1) {
-        return from(this.context.rpc.getBlock({ block: startBlock })).pipe(switchMap((block) => {
+        return from(this.context.readProvider.getBlock(startBlock)).pipe(switchMap((block) => {
             if (count === 1) {
                 return of(block);
             }
             return range(block.header.level, count - 1).pipe(startWith(block), concatMap((level) => __awaiter(this, void 0, void 0, function* () {
-                return this.context.rpc.getBlock({ block: String(level) });
+                return this.context.readProvider.getBlock(typeof level === 'number' ? level : level.header.level);
             })));
         }));
     }
@@ -1414,7 +1358,7 @@ class RpcTzProvider extends OperationEmitter {
             if (validateAddress(address) !== ValidationResult.VALID) {
                 throw new InvalidAddressError(`Invalid address: ${address}`);
             }
-            return this.rpc.getBalance(address);
+            return this.context.readProvider.getBalance(address, 'head');
         });
     }
     getDelegate(address) {
@@ -1422,7 +1366,7 @@ class RpcTzProvider extends OperationEmitter {
             if (validateAddress(address) !== ValidationResult.VALID) {
                 throw new InvalidAddressError(`Invalid address: ${address}`);
             }
-            return this.rpc.getDelegate(address);
+            return this.context.readProvider.getDelegate(address, 'head');
         });
     }
     activate(pkh, secret) {
@@ -1514,7 +1458,8 @@ class Estimate {
         return this.roundUp(Number(this._milligasLimit) / 1000 + GAS_BUFFER);
     }
     get operationFeeMutez() {
-        return ((Number(this._milligasLimit) / 1000 + GAS_BUFFER) * MINIMAL_FEE_PER_GAS_MUTEZ + Number(this.opSize) * MINIMAL_FEE_PER_BYTE_MUTEZ);
+        return ((Number(this._milligasLimit) / 1000 + GAS_BUFFER) * MINIMAL_FEE_PER_GAS_MUTEZ +
+            Number(this.opSize) * MINIMAL_FEE_PER_BYTE_MUTEZ);
     }
     roundUp(nanotez) {
         return Math.ceil(Number(nanotez));
@@ -1556,7 +1501,7 @@ class Estimate {
         let opSize = 0;
         let minimalFeePerStorageByteMutez = 0;
         let baseFeeMutez;
-        estimateProperties.forEach(estimate => {
+        estimateProperties.forEach((estimate) => {
             milligasLimit += estimate.milligasLimit;
             storageLimit += estimate.storageLimit;
             opSize += estimate.opSize;
@@ -1568,7 +1513,14 @@ class Estimate {
         return new Estimate(milligasLimit, storageLimit, opSize, minimalFeePerStorageByteMutez, baseFeeMutez);
     }
     static createArrayEstimateInstancesFromProperties(estimateProperties) {
-        return estimateProperties.map(x => new Estimate(x.milligasLimit, x.storageLimit, x.opSize, x.minimalFeePerStorageByteMutez, x.baseFeeMutez));
+        return estimateProperties.map((x) => new Estimate(x.milligasLimit, x.storageLimit, x.opSize, x.minimalFeePerStorageByteMutez, x.baseFeeMutez));
+    }
+}
+
+class RevealEstimateError extends Error {
+    constructor() {
+        super('Unable to estimate the reveal operation, the public key is unknown');
+        this.name = 'Reveal Estimate Error';
     }
 }
 
@@ -1592,10 +1544,21 @@ class RPCEstimateProvider extends OperationEmitter {
         this.ORIGINATION_STORAGE = 257;
         this.OP_SIZE_REVEAL = 128;
     }
+    getKeys() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isSignerConfigured = this.context.isAnySignerConfigured();
+            return {
+                publicKeyHash: isSignerConfigured
+                    ? yield this.signer.publicKeyHash()
+                    : yield this.context.walletProvider.getPKH(),
+                publicKey: isSignerConfigured ? yield this.signer.publicKey() : undefined,
+            };
+        });
+    }
     // Maximum values defined by the protocol
     getAccountLimits(pkh, constants, numberOfOps) {
         return __awaiter(this, void 0, void 0, function* () {
-            const balance = yield this.rpc.getBalance(pkh);
+            const balance = yield this.context.readProvider.getBalance(pkh, 'head');
             const { hard_gas_limit_per_operation, hard_gas_limit_per_block, hard_storage_limit_per_operation, cost_per_byte, } = constants;
             return {
                 fee: 0,
@@ -1655,13 +1618,13 @@ class RPCEstimateProvider extends OperationEmitter {
             };
         }
     }
-    prepareEstimate(params, constants) {
+    prepareEstimate(params, constants, pkh) {
         return __awaiter(this, void 0, void 0, function* () {
-            const prepared = yield this.prepareOperation(params);
+            const prepared = yield this.prepareOperation(params, pkh);
             const { opbytes, opOb: { branch, contents }, } = yield this.forge(prepared);
             const operation = {
                 operation: { branch, contents, signature: SIGNATURE_STUB },
-                chain_id: yield this.rpc.getChainId(),
+                chain_id: yield this.context.readProvider.getChainId(),
             };
             const { opResponse } = yield this.simulate(operation);
             const { cost_per_byte } = constants;
@@ -1695,13 +1658,13 @@ class RPCEstimateProvider extends OperationEmitter {
     originate(_a) {
         var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
         return __awaiter(this, void 0, void 0, function* () {
-            const pkh = yield this.signer.publicKeyHash();
-            const protocolConstants = yield this.rpc.getConstants();
-            const DEFAULT_PARAMS = yield this.getAccountLimits(pkh, protocolConstants);
+            const { publicKeyHash } = yield this.getKeys();
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+            const DEFAULT_PARAMS = yield this.getAccountLimits(publicKeyHash, protocolConstants);
             const op = yield createOriginationOperation(yield this.context.parser.prepareCodeOrigination(Object.assign(Object.assign({}, rest), mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS))));
-            const isRevealNeeded = yield this.isRevealOpNeeded([op], pkh);
-            const ops = isRevealNeeded ? yield this.addRevealOp([op], pkh) : op;
-            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants);
+            const isRevealNeeded = yield this.isRevealOpNeeded([op], publicKeyHash);
+            const ops = isRevealNeeded ? yield this.addRevealOp([op], publicKeyHash) : op;
+            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: publicKeyHash }, protocolConstants, publicKeyHash);
             if (isRevealNeeded) {
                 estimateProperties.shift();
             }
@@ -1725,13 +1688,13 @@ class RPCEstimateProvider extends OperationEmitter {
             if (rest.source && validateAddress(rest.source) !== ValidationResult.VALID) {
                 throw new InvalidAddressError(`Invalid 'source' address: ${rest.source}`);
             }
-            const pkh = yield this.signer.publicKeyHash();
-            const protocolConstants = yield this.rpc.getConstants();
+            const pkh = (yield this.getKeys()).publicKeyHash;
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
             const DEFAULT_PARAMS = yield this.getAccountLimits(pkh, protocolConstants);
             const op = yield createTransferOperation(Object.assign(Object.assign({}, rest), mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS)));
             const isRevealNeeded = yield this.isRevealOpNeeded([op], pkh);
             const ops = isRevealNeeded ? yield this.addRevealOp([op], pkh) : op;
-            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants);
+            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants, pkh);
             if (isRevealNeeded) {
                 estimateProperties.shift();
             }
@@ -1755,14 +1718,14 @@ class RPCEstimateProvider extends OperationEmitter {
             if (rest.delegate && validateAddress(rest.delegate) !== ValidationResult.VALID) {
                 throw new InvalidAddressError(`Invalid delegate address: ${rest.delegate}`);
             }
-            const pkh = yield this.signer.publicKeyHash();
+            const pkh = (yield this.getKeys()).publicKeyHash;
             const sourceOrDefault = rest.source || pkh;
-            const protocolConstants = yield this.rpc.getConstants();
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
             const DEFAULT_PARAMS = yield this.getAccountLimits(sourceOrDefault, protocolConstants);
             const op = yield createSetDelegateOperation(Object.assign(Object.assign({}, rest), mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS)));
             const isRevealNeeded = yield this.isRevealOpNeeded([op], pkh);
             const ops = isRevealNeeded ? yield this.addRevealOp([op], pkh) : op;
-            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants);
+            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants, pkh);
             if (isRevealNeeded) {
                 estimateProperties.shift();
             }
@@ -1777,10 +1740,10 @@ class RPCEstimateProvider extends OperationEmitter {
      */
     batch(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const pkh = yield this.signer.publicKeyHash();
+            const { publicKeyHash } = yield this.getKeys();
             let operations = [];
-            const protocolConstants = yield this.rpc.getConstants();
-            const DEFAULT_PARAMS = yield this.getAccountLimits(pkh, protocolConstants, params.length);
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+            const DEFAULT_PARAMS = yield this.getAccountLimits(publicKeyHash, protocolConstants, params.length);
             for (const param of params) {
                 switch (param.kind) {
                     case OpKind.TRANSACTION:
@@ -1802,9 +1765,9 @@ class RPCEstimateProvider extends OperationEmitter {
                         throw new Error(`Unsupported operation kind: ${param.kind}`);
                 }
             }
-            const isRevealNeeded = yield this.isRevealOpNeeded(operations, pkh);
-            operations = isRevealNeeded ? yield this.addRevealOp(operations, pkh) : operations;
-            const estimateProperties = yield this.prepareEstimate({ operation: operations, source: pkh }, protocolConstants);
+            const isRevealNeeded = yield this.isRevealOpNeeded(operations, publicKeyHash);
+            operations = isRevealNeeded ? yield this.addRevealOp(operations, publicKeyHash) : operations;
+            const estimateProperties = yield this.prepareEstimate({ operation: operations, source: publicKeyHash }, protocolConstants, publicKeyHash);
             return Estimate.createArrayEstimateInstancesFromProperties(estimateProperties);
         });
     }
@@ -1818,13 +1781,13 @@ class RPCEstimateProvider extends OperationEmitter {
      */
     registerDelegate(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const pkh = yield this.signer.publicKeyHash();
-            const protocolConstants = yield this.rpc.getConstants();
+            const pkh = (yield this.getKeys()).publicKeyHash;
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
             const DEFAULT_PARAMS = yield this.getAccountLimits(pkh, protocolConstants);
             const op = yield createRegisterDelegateOperation(Object.assign(Object.assign({}, params), DEFAULT_PARAMS), pkh);
             const isRevealNeeded = yield this.isRevealOpNeeded([op], pkh);
             const ops = isRevealNeeded ? yield this.addRevealOp([op], pkh) : op;
-            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants);
+            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants, pkh);
             if (isRevealNeeded) {
                 estimateProperties.shift();
             }
@@ -1841,12 +1804,15 @@ class RPCEstimateProvider extends OperationEmitter {
      */
     reveal(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const pkh = yield this.signer.publicKeyHash();
-            if (yield this.isAccountRevealRequired(pkh)) {
-                const protocolConstants = yield this.rpc.getConstants();
-                const DEFAULT_PARAMS = yield this.getAccountLimits(pkh, protocolConstants);
-                const op = yield createRevealOperation(Object.assign(Object.assign({}, params), DEFAULT_PARAMS), pkh, yield this.signer.publicKey());
-                const estimateProperties = yield this.prepareEstimate({ operation: op, source: pkh }, protocolConstants);
+            const { publicKeyHash, publicKey } = yield this.getKeys();
+            if (!publicKey) {
+                throw new RevealEstimateError();
+            }
+            if (yield this.isAccountRevealRequired(publicKeyHash)) {
+                const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+                const DEFAULT_PARAMS = yield this.getAccountLimits(publicKeyHash, protocolConstants);
+                const op = yield createRevealOperation(Object.assign(Object.assign({}, params), DEFAULT_PARAMS), publicKeyHash, publicKey);
+                const estimateProperties = yield this.prepareEstimate({ operation: op, source: publicKeyHash }, protocolConstants, publicKeyHash);
                 return Estimate.createEstimateInstanceFromProperties(estimateProperties);
             }
         });
@@ -1862,13 +1828,13 @@ class RPCEstimateProvider extends OperationEmitter {
     registerGlobalConstant(_a) {
         var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
         return __awaiter(this, void 0, void 0, function* () {
-            const pkh = yield this.signer.publicKeyHash();
-            const protocolConstants = yield this.rpc.getConstants();
+            const pkh = (yield this.getKeys()).publicKeyHash;
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
             const DEFAULT_PARAMS = yield this.getAccountLimits(pkh, protocolConstants);
             const op = yield createRegisterGlobalConstantOperation(Object.assign(Object.assign({}, rest), mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS)));
             const isRevealNeeded = yield this.isRevealOpNeeded([op], pkh);
             const ops = isRevealNeeded ? yield this.addRevealOp([op], pkh) : op;
-            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants);
+            const estimateProperties = yield this.prepareEstimate({ operation: ops, source: pkh }, protocolConstants, pkh);
             if (isRevealNeeded) {
                 estimateProperties.shift();
             }
@@ -1877,6 +1843,10 @@ class RPCEstimateProvider extends OperationEmitter {
     }
     addRevealOp(op, pkh) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { publicKey } = yield this.getKeys();
+            if (!publicKey) {
+                throw new RevealEstimateError();
+            }
             op.unshift(yield createRevealOperation(Object.assign({
                 fee: DEFAULT_FEE.REVEAL,
                 gasLimit: DEFAULT_GAS_LIMIT.REVEAL,
@@ -1996,12 +1966,12 @@ class OriginationOperation extends Operation {
     /**
      * @description Provide the contract abstract of the newly originated contract
      */
-    contract(confirmations, interval, timeout) {
+    contract(confirmations, timeout) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.contractAddress) {
                 throw new Error('No contract was originated in this operation');
             }
-            yield this.confirmation(confirmations, interval, timeout);
+            yield this.confirmation(confirmations, timeout);
             return this.contractProvider.at(this.contractAddress);
         });
     }
@@ -2495,9 +2465,6 @@ class Wallet {
         return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
             const mappedParams = yield this.walletProvider.mapOriginateParamsToWalletParams(() => this.context.parser.prepareCodeOrigination(Object.assign({}, params)));
             const opHash = yield this.walletProvider.sendOperations([mappedParams]);
-            if (!this.context.proto) {
-                this.context.proto = (yield this.context.rpc.getBlock()).protocol;
-            }
             return this.context.operationFactory.createOriginationOperation(opHash);
         }));
     }
@@ -2582,11 +2549,10 @@ class Wallet {
                 throw new InvalidContractAddressError(`Invalid contract address: ${address}`);
             }
             const rpc = this.context.withExtensions().rpc;
-            const script = yield rpc.getNormalizedScript(address);
-            const entrypoints = yield rpc.getEntrypoints(address);
-            const blockHeader = yield this.context.rpc.getBlockHeader();
-            const chainId = blockHeader.chain_id;
-            const abs = new ContractAbstraction(address, script, this, this.context.contract, entrypoints, chainId, rpc);
+            const readProvider = this.context.withExtensions().readProvider;
+            const script = yield readProvider.getScript(address, 'head');
+            const entrypoints = yield readProvider.getEntrypoints(address);
+            const abs = new ContractAbstraction(address, script, this, this.context.contract, entrypoints, rpc, readProvider);
             return contractAbstractionComposer(abs, this.context);
         });
     }
@@ -2713,12 +2679,12 @@ const runCodeHelper = (viewArgsType, viewReturnType, contractStorageType, viewIn
     };
 };
 class OnChainView {
-    constructor(_rpc, _contractAddress, _smartContractViewSchema, _contractStorageType, _contractStorageValue, _args = 'Unit') {
+    constructor(_rpc, _readProvider, _contractAddress, _smartContractViewSchema, _contractStorageType, _args = 'Unit') {
         this._rpc = _rpc;
+        this._readProvider = _readProvider;
         this._contractAddress = _contractAddress;
         this._smartContractViewSchema = _smartContractViewSchema;
         this._contractStorageType = _contractStorageType;
-        this._contractStorageValue = _contractStorageValue;
         this._args = _args;
     }
     /**
@@ -2738,9 +2704,10 @@ class OnChainView {
     executeView(executionContext) {
         return __awaiter(this, void 0, void 0, function* () {
             this.verifyContextExecution(executionContext);
-            const balance = (yield this._rpc.getBalance(this._contractAddress)).toString();
-            const chainId = yield this._rpc.getChainId();
-            return this.executeViewAndDecodeResult(runCodeHelper(this._smartContractViewSchema.viewArgsType, this._smartContractViewSchema.viewReturnType, this._contractStorageType, this.adaptViewCodeToContext(this._smartContractViewSchema.instructions, executionContext.viewCaller, balance), this.transformArgsToMichelson(), this._contractStorageValue, balance, chainId, executionContext.source));
+            const balance = (yield this._readProvider.getBalance(this._contractAddress, 'head')).toString();
+            const chainId = yield this._readProvider.getChainId();
+            const storage = yield this._readProvider.getStorage(this._contractAddress, 'head');
+            return this.executeViewAndDecodeResult(runCodeHelper(this._smartContractViewSchema.viewArgsType, this._smartContractViewSchema.viewReturnType, this._contractStorageType, this.adaptViewCodeToContext(this._smartContractViewSchema.instructions, executionContext.viewCaller, balance), this.transformArgsToMichelson(), storage, balance, chainId, executionContext.source));
         });
     }
     verifyContextExecution(executionContext) {
@@ -2824,247 +2791,8 @@ class ContractMethodFactory {
     createContractMethodObjectParam(smartContractMethodSchema, smartContractMethodName, args, isMultipleEntrypoint = true, isAnonymous = false) {
         return new ContractMethodObject(this.provider, this.contractAddress, smartContractMethodSchema, smartContractMethodName, args, isMultipleEntrypoint, isAnonymous);
     }
-    createContractViewObjectParam(rpc, smartContractViewSchema, contractStorageType, contractStorageValue, viewArgs) {
-        return new OnChainView(rpc, this.contractAddress, smartContractViewSchema, contractStorageType, contractStorageValue, viewArgs);
-    }
-}
-
-class LambdaView {
-    constructor(lambdaContract, viewContract, viewMethod = 'default', contractParameter = { prim: 'Unit' }) {
-        this.lambdaContract = lambdaContract;
-        this.viewContract = viewContract;
-        this.viewMethod = viewMethod;
-        this.contractParameter = contractParameter;
-        this.voidLambda = this.createVoidLambda();
-    }
-    execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.lambdaContract.methods.default(this.voidLambda).send();
-            }
-            catch (ex) {
-                if (ex instanceof TezosOperationError) {
-                    const lastError = ex.errors[ex.errors.length - 1];
-                    const failedWith = lastError.with;
-                    return failedWith;
-                }
-                else {
-                    throw ex;
-                }
-            }
-        });
-    }
-    createVoidLambda() {
-        const [parameter, callback] = this.getView();
-        let contractArgs = [
-            {
-                prim: 'pair',
-                args: [parameter, { prim: 'contract', args: [callback] }],
-            },
-        ];
-        if (this.viewMethod === 'default') {
-            contractArgs = [{ string: '%default' }].concat(contractArgs);
-        }
-        return [
-            { prim: 'PUSH', args: [{ prim: 'mutez' }, { int: '0' }] },
-            { prim: 'NONE', args: [{ prim: 'key_hash' }] },
-            {
-                prim: 'CREATE_CONTRACT',
-                args: [
-                    [
-                        { prim: 'parameter', args: [callback] },
-                        { prim: 'storage', args: [{ prim: 'unit' }] },
-                        {
-                            prim: 'code',
-                            args: [[{ prim: 'CAR' }, { prim: 'FAILWITH' }]],
-                        },
-                    ],
-                ],
-            },
-            {
-                prim: 'DIP',
-                args: [
-                    [
-                        {
-                            prim: 'DIP',
-                            args: [
-                                [
-                                    {
-                                        prim: 'LAMBDA',
-                                        args: [
-                                            {
-                                                prim: 'pair',
-                                                args: [{ prim: 'address' }, { prim: 'unit' }],
-                                            },
-                                            {
-                                                prim: 'pair',
-                                                args: [{ prim: 'list', args: [{ prim: 'operation' }] }, { prim: 'unit' }],
-                                            },
-                                            [
-                                                { prim: 'CAR' },
-                                                { prim: 'CONTRACT', args: [callback] },
-                                                {
-                                                    prim: 'IF_NONE',
-                                                    args: [
-                                                        [
-                                                            {
-                                                                prim: 'PUSH',
-                                                                args: [{ prim: 'string' }, { string: `Callback type unmatched` }],
-                                                            },
-                                                            { prim: 'FAILWITH' },
-                                                        ],
-                                                        [],
-                                                    ],
-                                                },
-                                                {
-                                                    prim: 'PUSH',
-                                                    args: [parameter, this.contractParameter],
-                                                },
-                                                { prim: 'PAIR' },
-                                                {
-                                                    prim: 'DIP',
-                                                    args: [
-                                                        [
-                                                            {
-                                                                prim: 'PUSH',
-                                                                args: [
-                                                                    { prim: 'address' },
-                                                                    { string: `${this.viewContract.address}%${this.viewMethod}` },
-                                                                ],
-                                                            },
-                                                            { prim: 'DUP' },
-                                                            { prim: 'CONTRACT', args: contractArgs },
-                                                            {
-                                                                prim: 'IF_NONE',
-                                                                args: [
-                                                                    [
-                                                                        {
-                                                                            prim: 'PUSH',
-                                                                            args: [
-                                                                                { prim: 'string' },
-                                                                                { string: `Contract does not exist` },
-                                                                            ],
-                                                                        },
-                                                                        { prim: 'FAILWITH' },
-                                                                    ],
-                                                                    [{ prim: 'DIP', args: [[{ prim: 'DROP' }]] }],
-                                                                ],
-                                                            },
-                                                            {
-                                                                prim: 'PUSH',
-                                                                args: [{ prim: 'mutez' }, { int: '0' }],
-                                                            },
-                                                        ],
-                                                    ],
-                                                },
-                                                { prim: 'TRANSFER_TOKENS' },
-                                                {
-                                                    prim: 'DIP',
-                                                    args: [[{ prim: 'NIL', args: [{ prim: 'operation' }] }]],
-                                                },
-                                                { prim: 'CONS' },
-                                                { prim: 'DIP', args: [[{ prim: 'UNIT' }]] },
-                                                { prim: 'PAIR' },
-                                            ],
-                                        ],
-                                    },
-                                ],
-                            ],
-                        },
-                        { prim: 'APPLY' },
-                        {
-                            prim: 'DIP',
-                            args: [
-                                [
-                                    {
-                                        prim: 'PUSH',
-                                        args: [{ prim: 'address' }, { string: this.lambdaContract.address }],
-                                    },
-                                    { prim: 'DUP' },
-                                    {
-                                        prim: 'CONTRACT',
-                                        args: [
-                                            {
-                                                prim: 'lambda',
-                                                args: [
-                                                    { prim: 'unit' },
-                                                    {
-                                                        prim: 'pair',
-                                                        args: [
-                                                            { prim: 'list', args: [{ prim: 'operation' }] },
-                                                            { prim: 'unit' },
-                                                        ],
-                                                    },
-                                                ],
-                                            },
-                                        ],
-                                    },
-                                    {
-                                        prim: 'IF_NONE',
-                                        args: [
-                                            [
-                                                {
-                                                    prim: 'PUSH',
-                                                    args: [{ prim: 'string' }, { string: `Contract does not exists` }],
-                                                },
-                                                { prim: 'FAILWITH' },
-                                            ],
-                                            [{ prim: 'DIP', args: [[{ prim: 'DROP' }]] }],
-                                        ],
-                                    },
-                                    { prim: 'PUSH', args: [{ prim: 'mutez' }, { int: '0' }] },
-                                ],
-                            ],
-                        },
-                        { prim: 'TRANSFER_TOKENS' },
-                        {
-                            prim: 'DIP',
-                            args: [[{ prim: 'NIL', args: [{ prim: 'operation' }] }]],
-                        },
-                        { prim: 'CONS' },
-                    ],
-                ],
-            },
-            { prim: 'CONS' },
-            { prim: 'DIP', args: [[{ prim: 'UNIT' }]] },
-            { prim: 'PAIR' },
-        ];
-    }
-    getView() {
-        const entrypoints = this.viewContract.entrypoints.entrypoints;
-        const entrypoint = entrypoints[this.viewMethod];
-        if (!entrypoint) {
-            throw Error(`Contract at ${this.viewContract.address} does not have entrypoint: ${this.viewMethod}`);
-        }
-        if (!('prim' in entrypoint) || !entrypoint.args) {
-            // TODO: Enhance this error message to be more descriptive
-            throw Error('Entrypoint args undefined');
-        }
-        const args = Array.from(entrypoint.args);
-        const [parameter, callbackContract] = args;
-        if ('annots' in parameter) {
-            delete parameter['annots'];
-        }
-        if (!('prim' in callbackContract) || !callbackContract.args) {
-            // TODO: Enhance this error message to be more descriptive
-            throw Error('Callback contract args undefined');
-        }
-        let message;
-        if (entrypoint.prim !== 'pair') {
-            message = `Expected {'prim': 'pair', ..} but found {'prim': ${entrypoint.prim}, ..}`;
-        }
-        else if (args.length !== 2) {
-            message = `Expected an Array of length 2, but found: ${args}`;
-        }
-        else if (callbackContract.prim !== 'contract') {
-            message = `Expected a {prim: 'contract', ...}, but found: ${callbackContract.prim}`;
-        }
-        else if (callbackContract.args && callbackContract.args.length !== 1) {
-            message = `Expected a single argument to 'contract', but found: ${callbackContract.args}`;
-        }
-        if (message)
-            throw Error(message);
-        return [parameter, callbackContract.args[0]];
+    createContractViewObjectParam(rpc, readProvider, smartContractViewSchema, contractStorageType, viewArgs) {
+        return new OnChainView(rpc, readProvider, this.contractAddress, smartContractViewSchema, contractStorageType, viewArgs);
     }
 }
 
@@ -3073,55 +2801,31 @@ const DEFAULT_SMART_CONTRACT_METHOD_NAME = 'default';
  * @description Utility class to retrieve data from a smart contract's storage without incurring fees via a contract's view method
  */
 class ContractView {
-    constructor(currentContract, provider, name, chainId, callbackParametersSchema, parameterSchema, args) {
+    constructor(currentContract, name, callbackParametersSchema, parameterSchema, args, rpc, readProvider) {
         this.currentContract = currentContract;
-        this.provider = provider;
         this.name = name;
-        this.chainId = chainId;
         this.callbackParametersSchema = callbackParametersSchema;
         this.parameterSchema = parameterSchema;
         this.args = args;
+        this.rpc = rpc;
+        this.readProvider = readProvider;
     }
-    /**
-     *
-     * @description Find which lambda contract to use based on the current network,
-     * encode parameters to Michelson,
-     * create an instance of Lambdaview to retrieve data, and
-     * Decode Michelson response
-     *
-     * @param Options Address of a lambda contract (sandbox users)
-     */
-    read(customLambdaAddress) {
+    read(chainId) {
         return __awaiter(this, void 0, void 0, function* () {
-            let lambdaAddress;
-            // TODO Verify if the 'customLambdaAdress' is a valid originated contract and if not, return an appropriate error message.  
-            if (customLambdaAddress) {
-                lambdaAddress = customLambdaAddress;
-            }
-            else if (this.chainId === ChainIds.GRANADANET) {
-                lambdaAddress = DefaultLambdaAddresses.GRANADANET;
-            }
-            else if (this.chainId === ChainIds.HANGZHOUNET) {
-                lambdaAddress = DefaultLambdaAddresses.HANGZHOUNET;
-            }
-            else if (this.chainId === ChainIds.ITHACANET) {
-                lambdaAddress = DefaultLambdaAddresses.ITHACANET;
+            if (validateContractAddress(chainId) == ValidationResult.VALID) {
+                throw new Error(`Since version 12, the lambda view no longer depends on a lambda contract. The read method no longer accepts a contract address as a parameter.`);
             }
-            else if (this.chainId === ChainIds.ITHACANET2) {
-                lambdaAddress = DefaultLambdaAddresses.ITHACANET2;
+            else if (chainId && validateChain(chainId) !== ValidationResult.VALID) {
+                throw new Error('ChainId is invalid');
             }
-            else if (this.chainId === ChainIds.MAINNET) {
-                lambdaAddress = DefaultLambdaAddresses.MAINNET;
-            }
-            else {
-                throw new UndefinedLambdaContractError();
-            }
-            const lambdaContract = yield this.provider.at(lambdaAddress);
             const arg = this.parameterSchema.Encode(...this.args);
-            const lambdaView = new LambdaView(lambdaContract, this.currentContract, this.name, arg);
-            const failedWith = yield lambdaView.execute();
-            const response = this.callbackParametersSchema.Execute(failedWith);
-            return response;
+            const result = yield this.rpc.runView({
+                contract: this.currentContract.address,
+                entrypoint: this.name,
+                input: arg,
+                chain_id: chainId ? chainId : yield this.readProvider.getChainId(),
+            });
+            return this.callbackParametersSchema.Execute(result.data);
         });
     }
 }
@@ -3142,17 +2846,17 @@ const isView = (entrypoint) => {
     }
     return isView;
 };
-const isContractProvider = (variableToCheck) => variableToCheck.contractProviderTypeSymbol !== undefined;
 /**
  * @description Smart contract abstraction
  */
 class ContractAbstraction {
-    constructor(address, script, provider, storageProvider, entrypoints, chainId, rpc) {
+    constructor(address, script, provider, storageProvider, entrypoints, rpc, readProvider) {
         this.address = address;
         this.script = script;
         this.storageProvider = storageProvider;
         this.entrypoints = entrypoints;
-        this.chainId = chainId;
+        this.rpc = rpc;
+        this.readProvider = readProvider;
         /**
          * @description Contains methods that are implemented by the target Tezos Smart Contract, and offers the user to call the Smart Contract methods as if they were native TS/JS methods.
          * NB: if the contract contains annotation it will include named properties; if not it will be indexed by a number.
@@ -3182,11 +2886,11 @@ class ContractAbstraction {
         this.parameterSchema = ParameterSchema.fromRPCResponse({ script: this.script });
         this.viewSchema = ViewSchema.fromRPCResponse({ script: this.script });
         if (this.viewSchema.length !== 0) {
-            this._initializeOnChainViews(this, rpc, this.viewSchema);
+            this._initializeOnChainViews(this, rpc, this.readProvider, this.viewSchema);
         }
-        this._initializeMethods(this, provider, this.entrypoints.entrypoints, this.chainId);
+        this._initializeMethods(this, this.entrypoints.entrypoints, this.rpc, this.readProvider);
     }
-    _initializeMethods(currentContract, provider, entrypoints, chainId) {
+    _initializeMethods(currentContract, entrypoints, rpc, readProvider) {
         const parameterSchema = this.parameterSchema;
         const keys = Object.keys(entrypoints);
         if (parameterSchema.isMultipleEntryPoint) {
@@ -3198,20 +2902,18 @@ class ContractAbstraction {
                 this.methodsObject[smartContractMethodName] = function (args) {
                     return currentContract.contractMethodFactory.createContractMethodObjectParam(smartContractMethodSchema, smartContractMethodName, args);
                 };
-                if (isContractProvider(provider)) {
-                    if (isView(entrypoints[smartContractMethodName])) {
-                        const view = function (...args) {
-                            const entrypointParamWithoutCallback = entrypoints[smartContractMethodName]
-                                .args[0];
-                            const smartContractMethodSchemaWithoutCallback = new ParameterSchema(entrypointParamWithoutCallback);
-                            const parametersCallback = entrypoints[smartContractMethodName].args[1]
-                                .args[0];
-                            const smartContractMethodCallbackSchema = new ParameterSchema(parametersCallback);
-                            validateArgs(args, smartContractMethodSchemaWithoutCallback, smartContractMethodName);
-                            return new ContractView(currentContract, provider, smartContractMethodName, chainId, smartContractMethodCallbackSchema, smartContractMethodSchemaWithoutCallback, args);
-                        };
-                        this.views[smartContractMethodName] = view;
-                    }
+                if (isView(entrypoints[smartContractMethodName])) {
+                    const view = function (...args) {
+                        const entrypointParamWithoutCallback = entrypoints[smartContractMethodName]
+                            .args[0];
+                        const smartContractMethodSchemaWithoutCallback = new ParameterSchema(entrypointParamWithoutCallback);
+                        const parametersCallback = entrypoints[smartContractMethodName].args[1]
+                            .args[0];
+                        const smartContractMethodCallbackSchema = new ParameterSchema(parametersCallback);
+                        validateArgs(args, smartContractMethodSchemaWithoutCallback, smartContractMethodName);
+                        return new ContractView(currentContract, smartContractMethodName, smartContractMethodCallbackSchema, smartContractMethodSchemaWithoutCallback, args, rpc, readProvider);
+                    };
+                    this.views[smartContractMethodName] = view;
                 }
             });
             // Deal with methods with no annotations which were not discovered by the RPC endpoint
@@ -3231,17 +2933,17 @@ class ContractAbstraction {
             this.methods[DEFAULT_SMART_CONTRACT_METHOD_NAME] = function (...args) {
                 return currentContract.contractMethodFactory.createContractMethodFlatParams(smartContractMethodSchema, DEFAULT_SMART_CONTRACT_METHOD_NAME, args, false);
             };
-            this.methodsObject[DEFAULT_SMART_CONTRACT_METHOD_NAME] = function (args) {
-                return currentContract.contractMethodFactory.createContractMethodObjectParam(smartContractMethodSchema, DEFAULT_SMART_CONTRACT_METHOD_NAME, args, false);
-            };
+            this.methodsObject[DEFAULT_SMART_CONTRACT_METHOD_NAME] =
+                function (args) {
+                    return currentContract.contractMethodFactory.createContractMethodObjectParam(smartContractMethodSchema, DEFAULT_SMART_CONTRACT_METHOD_NAME, args, false);
+                };
         }
     }
-    _initializeOnChainViews(currentContract, rpc, allContractViews) {
+    _initializeOnChainViews(currentContract, rpc, readProvider, allContractViews) {
         const storageType = this.schema.val;
-        const storageValue = this.script.storage;
         allContractViews.forEach((viewSchema) => {
             this.contractViews[viewSchema.viewName] = function (args) {
-                return currentContract.contractMethodFactory.createContractViewObjectParam(rpc, viewSchema, storageType, storageValue, args);
+                return currentContract.contractMethodFactory.createContractViewObjectParam(rpc, readProvider, viewSchema, storageType, args);
             };
         });
     }
@@ -3395,8 +3097,9 @@ class RpcContractProvider extends OperationEmitter {
             if (validateContractAddress(contract) !== ValidationResult.VALID) {
                 throw new InvalidContractAddressError(`Invalid contract address: ${contract}`);
             }
+            const script = yield this.context.readProvider.getScript(contract, 'head');
             if (!schema) {
-                schema = yield this.rpc.getNormalizedScript(contract);
+                schema = script;
             }
             let contractSchema;
             if (Schema.isSchema(schema)) {
@@ -3405,8 +3108,7 @@ class RpcContractProvider extends OperationEmitter {
             else {
                 contractSchema = Schema.fromRPCResponse({ script: schema });
             }
-            const storage = yield this.rpc.getStorage(contract);
-            return contractSchema.Execute(storage, smartContractAbstractionSemantic(this)); // Cast into T because only the caller can know the true type of the storage
+            return contractSchema.Execute(script.storage, smartContractAbstractionSemantic(this)); // Cast into T because only the caller can know the true type of the storage
         });
     }
     /**
@@ -3458,8 +3160,8 @@ class RpcContractProvider extends OperationEmitter {
             const { packed } = yield this.context.packer.packData({ data: key, type });
             const encodedExpr = encodeExpr(packed);
             const bigMapValue = block
-                ? yield this.context.rpc.getBigMapExpr(id.toString(), encodedExpr, { block: String(block) })
-                : yield this.context.rpc.getBigMapExpr(id.toString(), encodedExpr);
+                ? yield this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, block)
+                : yield this.context.readProvider.getBigMapValue({ id: id.toString(), expr: encodedExpr }, 'head');
             return schema.ExecuteOnBigMapValue(bigMapValue, smartContractAbstractionSemantic(this));
         });
     }
@@ -3498,11 +3200,10 @@ class RpcContractProvider extends OperationEmitter {
         });
     }
     getBlockForRequest(keys, block) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             return keys.length === 1 || typeof block !== 'undefined'
                 ? block
-                : (_a = (yield this.rpc.getBlock())) === null || _a === void 0 ? void 0 : _a.header.level;
+                : yield this.context.readProvider.getBlockLevel('head');
         });
     }
     getBigMapValueOrUndefined(keyToEncode, id, schema, level) {
@@ -3531,8 +3232,8 @@ class RpcContractProvider extends OperationEmitter {
     getSaplingDiffByID(id, block) {
         return __awaiter(this, void 0, void 0, function* () {
             const saplingState = block
-                ? yield this.context.rpc.getSaplingDiffById(id.toString(), { block: String(block) })
-                : yield this.context.rpc.getSaplingDiffById(id.toString());
+                ? yield this.context.readProvider.getSaplingDiffById({ id: id.toString() }, block)
+                : yield this.context.readProvider.getSaplingDiffById({ id: id.toString() }, 'head');
             return saplingState;
         });
     }
@@ -3709,11 +3410,10 @@ class RpcContractProvider extends OperationEmitter {
                 throw new InvalidContractAddressError(`Invalid contract address: ${address}`);
             }
             const rpc = this.context.withExtensions().rpc;
-            const script = yield rpc.getNormalizedScript(address);
-            const entrypoints = yield rpc.getEntrypoints(address);
-            const blockHeader = yield this.rpc.getBlockHeader();
-            const chainId = blockHeader.chain_id;
-            const abs = new ContractAbstraction(address, script, this, this, entrypoints, chainId, rpc);
+            const readProvider = this.context.withExtensions().readProvider;
+            const script = yield readProvider.getScript(address, 'head');
+            const entrypoints = yield readProvider.getEntrypoints(address);
+            const abs = new ContractAbstraction(address, script, this, this, entrypoints, rpc, readProvider);
             return contractAbstractionComposer(abs, this.context);
         });
     }
@@ -3740,8 +3440,11 @@ class MichelCodecParser {
     }
     getNextProto() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { next_protocol } = yield this.context.rpc.getBlockMetadata();
-            return next_protocol;
+            if (!this.context.proto) {
+                const nextProto = yield this.context.readProvider.getNextProtocol('head');
+                this.context.proto = nextProto;
+            }
+            return this.context.proto;
         });
     }
     parseScript(src) {
@@ -3881,175 +3584,189 @@ class NoopGlobalConstantsProvider {
     }
 }
 
-const defaultConfigConfirmation = {
-    defaultConfirmationCount: 1,
-    confirmationPollingTimeoutSecond: 180,
-};
-const defaultConfigStreamer = {
-    streamerPollingIntervalMilliseconds: 20000,
-    shouldObservableSubscriptionRetry: false,
-    observableSubscriptionRetryFunction: retry(),
-};
 /**
- * @description Encapsulate common service used throughout different part of the library
+ * @description Converts calls from TzReadProvider into calls to the wrapped RpcClient in a format it can understand.
  */
-class Context {
-    constructor(_rpc, _signer = new NoopSigner(), _proto, _config = new BehaviorSubject(Object.assign(Object.assign({}, defaultConfigStreamer), defaultConfigConfirmation)), forger, injector, packer, wallet, parser, globalConstantsProvider) {
-        this._rpc = _rpc;
-        this._signer = _signer;
-        this._proto = _proto;
-        this._config = _config;
-        this.providerDecorator = [];
-        this.tz = new RpcTzProvider(this);
-        this.estimate = new RPCEstimateProvider(this);
-        this.contract = new RpcContractProvider(this, this.estimate);
-        this.batch = new RPCBatchProvider(this, this.estimate);
-        this.wallet = new Wallet(this);
-        /**
-         * @description Applies the decorators on a cloned instance of the context and returned this cloned instance.
-         * The decorators are functions that inject logic into the context.
-         * They are provided by the extensions set on the TezosToolkit by calling the registerProviderDecorator method.
-         */
-        this.withExtensions = () => {
-            let clonedContext = this.clone();
-            this.providerDecorator.forEach((decorator) => {
-                clonedContext = decorator(clonedContext);
-            });
-            return clonedContext;
-        };
-        if (typeof this._rpc === 'string') {
-            this._rpcClient = new RpcClient(this._rpc);
-        }
-        else {
-            this._rpcClient = this._rpc;
-        }
-        this._forger = forger ? forger : new RpcForger(this);
-        this._injector = injector ? injector : new RpcInjector(this);
-        this.operationFactory = new OperationFactory(this);
-        this._walletProvider = wallet ? wallet : new LegacyWalletProvider(this);
-        this._parser = parser ? parser : new MichelCodecParser(this);
-        this._packer = packer ? packer : new RpcPacker(this);
-        this._globalConstantsProvider = globalConstantsProvider
-            ? globalConstantsProvider
-            : new NoopGlobalConstantsProvider();
+class RpcReadAdapter {
+    constructor(context) {
+        this.context = context;
     }
-    get config() {
-        return this._config.getValue();
+    /**
+     * @description Access the balance of a contract.
+     * @param address address from which we want to retrieve the 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.context.rpc.getBalance(address, { block: String(block) });
+        });
     }
-    set config(value) {
-        this._config.next(Object.assign({}, value));
+    /**
+     * @description 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.context.rpc.getDelegate(address, { block: String(block) });
+        });
     }
-    setPartialConfig(value) {
-        this._config.next(Object.assign(Object.assign({}, this._config.getValue()), value));
+    /**
+     * @description 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.context.rpc.getProtocols({ block: String(block) });
+            return protocols.next_protocol;
+        });
     }
-    get rpc() {
-        return this._rpcClient;
+    /**
+     * @description 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, } = yield this.context.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,
+            };
+        });
     }
-    set rpc(value) {
-        this._rpcClient = value;
+    /**
+     * @description 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* () {
+            return this.context.rpc.getNormalizedScript(contract, { unparsing_mode: 'Readable' }, { block: String(block) });
+        });
     }
-    get injector() {
-        return this._injector;
+    /**
+     * @description 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.context.rpc.getStorage(contract, { block: String(block) });
+        });
     }
-    set injector(value) {
-        this._injector = value;
+    /**
+     * @description Access the block hash
+     */
+    getBlockHash(block) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { hash } = yield this.context.rpc.getBlockHeader({ block: String(block) });
+            return hash;
+        });
     }
-    get forger() {
-        return this._forger;
+    /**
+     * @description Access the block level
+     */
+    getBlockLevel(block) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { level } = yield this.context.rpc.getBlockHeader({ block: String(block) });
+            return level;
+        });
     }
-    set forger(value) {
-        this._forger = value;
+    /**
+     * @description 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.context.rpc.getContract(pkh, { block: String(block) });
+            return counter || '0';
+        });
     }
-    get signer() {
-        return this._signer;
+    /**
+     * @description 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.context.rpc.getBlockHeader({ block: String(block) });
+            return timestamp;
+        });
     }
-    set signer(value) {
-        this._signer = value;
+    /**
+     * @description 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.context.rpc.getBigMapExpr(bigMapQuery.id, bigMapQuery.expr, {
+                block: String(block),
+            });
+        });
     }
-    get walletProvider() {
-        return this._walletProvider;
+    /**
+     * @description Access the value associated with a sapling state ID.
+     * @param id Sapling state ID
+     * @param block from which we want to retrieve the sapling state
+     */
+    getSaplingDiffById(saplingStateQuery, block) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.context.rpc.getSaplingDiffById(saplingStateQuery.id, { block: String(block) });
+        });
     }
-    set walletProvider(value) {
-        this._walletProvider = value;
+    /**
+     * @description 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.context.rpc.getEntrypoints(contract);
+        });
     }
-    set proto(value) {
-        this._proto = value;
+    /**
+     * @description Access the chain id
+     */
+    getChainId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.context.rpc.getChainId();
+        });
     }
-    get proto() {
-        return this._proto;
+    /**
+     * @description 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.context.rpc.getManagerKey(publicKeyHash, { block: String(block) });
+            const haveManager = manager && typeof manager === 'object' ? !!manager.key : !!manager;
+            return haveManager;
+        });
     }
-    get parser() {
-        return this._parser;
-    }
-    set parser(value) {
-        this._parser = value;
-    }
-    get packer() {
-        return this._packer;
-    }
-    set packer(value) {
-        this._packer = value;
-    }
-    get globalConstantsProvider() {
-        return this._globalConstantsProvider;
-    }
-    set globalConstantsProvider(value) {
-        this._globalConstantsProvider = value;
-    }
-    isAnyProtocolActive(protocol = []) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._proto) {
-                return protocol.includes(this._proto);
-            }
-            else {
-                const { next_protocol } = yield this.rpc.getBlockMetadata();
-                return protocol.includes(next_protocol);
-            }
-        });
-    }
-    getConfirmationPollingInterval() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Granada will generally halve the time between blocks, from 60 seconds to 30 seconds (mainnet).
-            // We reduce the default value in the same proportion, from 10 to 5.
-            const defaultInterval = 5;
-            try {
-                const constants = yield this.rpc.getConstants();
-                let blockTime = constants.time_between_blocks[0];
-                if (constants.minimal_block_delay !== undefined) {
-                    blockTime = constants.minimal_block_delay;
-                }
-                let confirmationPollingInterval = BigNumber.sum(blockTime, 
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                new BigNumber(constants.delay_per_missing_endorsement).multipliedBy(
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                Math.max(0, constants.initial_endorsers - constants.endorsers_per_block)));
-                // Divide the polling interval by a constant 3
-                // to improvise for polling time to work in prod,
-                // testnet and sandbox enviornment.
-                confirmationPollingInterval = confirmationPollingInterval.dividedBy(3);
-                this.config.confirmationPollingIntervalSecond =
-                    confirmationPollingInterval.toNumber() === 0 ? 0.1 : confirmationPollingInterval.toNumber();
-                return this.config.confirmationPollingIntervalSecond;
-            }
-            catch (exception) {
-                // Return default value if there is
-                // an issue returning from constants
-                // file.
-                return defaultInterval;
-            }
-        });
-    }
-    /**
-     * @description Create a copy of the current context. Useful when you have long running operation and you do not want a context change to affect the operation
-     */
-    clone() {
-        return new Context(this.rpc, this.signer, this.proto, this._config, this.forger, this._injector, this.packer);
+    /**
+     * @description 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.context.rpc.getBlock({ block: String(block) });
+        });
     }
     /**
-     * @description Allows extensions set on the TezosToolkit to inject logic into the context
+     * @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.
+     * @param block from which we want to retrieve the information
      */
-    registerProviderDecorator(fx) {
-        this.providerDecorator.push(fx);
+    getLiveBlocks(block) {
+        return this.context.rpc.getLiveBlocks({ block: String(block) });
     }
 }
 
@@ -4198,11 +3915,15 @@ class ObservableSubscription {
     }
 }
 
+const defaultConfigStreamer = {
+    shouldObservableSubscriptionRetry: false,
+    observableSubscriptionRetryFunction: retry(),
+};
 const getLastBlock = (context) => {
     return from(context.rpc.getBlock()).pipe(first());
 };
-const applyFilter = (filter) => concatMap(block => {
-    return new Observable(sub => {
+const applyFilter = (filter) => concatMap((block) => {
+    return new Observable((sub) => {
         for (const ops of block.operations) {
             for (const op of ops) {
                 for (const content of op.contents) {
@@ -4216,24 +3937,237 @@ const applyFilter = (filter) => concatMap(block => {
     });
 });
 class PollingSubscribeProvider {
-    constructor(context) {
+    constructor(context, config = {}) {
         this.context = context;
-        // Map the changing polling interval to a timer, which will automatically terminate the previous timer when the next one starts.
-        this.timer$ = this.context._config.pipe(switchMap((val) => timer(0, val.streamerPollingIntervalMilliseconds)));
-        this.newBlock$ = this.timer$.pipe(map(() => this.context), switchMap(getLastBlock), distinctUntilKeyChanged('hash'), publish(), refCount());
+        this._config$ = new BehaviorSubject(Object.assign(Object.assign({}, defaultConfigStreamer), config));
+        this.timer$ = this._config$.pipe(pluck('pollingIntervalMilliseconds'), switchMap((pollingIntervalMilliseconds) => {
+            if (!pollingIntervalMilliseconds) {
+                return from(this.getConfirmationPollingInterval()).pipe(switchMap((interval) => {
+                    return timer(0, interval);
+                }));
+            }
+            else {
+                return timer(0, pollingIntervalMilliseconds);
+            }
+        }));
+        this.newBlock$ = this.timer$.pipe(switchMap(() => getLastBlock(this.context)), distinctUntilKeyChanged('hash'), publish(), refCount());
+    }
+    get config() {
+        return this._config$.getValue();
+    }
+    getConfirmationPollingInterval() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.config.pollingIntervalMilliseconds) {
+                const defaultIntervalTestnetsMainnet = 5000;
+                const defaultIntervalSandbox = 1000;
+                try {
+                    const constants = yield this.context.readProvider.getProtocolConstants('head');
+                    const blockTime = constants.minimal_block_delay
+                        ? constants.minimal_block_delay.multipliedBy(1000)
+                        : constants.time_between_blocks
+                            ? constants.time_between_blocks[0].multipliedBy(1000)
+                            : new BigNumber(defaultIntervalTestnetsMainnet);
+                    const confirmationPollingInterval = blockTime.dividedBy(3);
+                    this.config.pollingIntervalMilliseconds =
+                        confirmationPollingInterval.toNumber() === 0
+                            ? defaultIntervalSandbox
+                            : confirmationPollingInterval.toNumber();
+                }
+                catch (exception) {
+                    return defaultIntervalTestnetsMainnet;
+                }
+            }
+            return this.config.pollingIntervalMilliseconds;
+        });
+    }
+    subscribeBlock(_filter) {
+        return new ObservableSubscription(this.newBlock$, this.config.shouldObservableSubscriptionRetry, this.config.observableSubscriptionRetryFunction);
     }
     subscribe(_filter) {
-        return new ObservableSubscription(this.newBlock$.pipe(pluck('hash')), this.context.config.shouldObservableSubscriptionRetry, this.context.config.observableSubscriptionRetryFunction);
+        return new ObservableSubscription(this.newBlock$.pipe(pluck('hash')), this.config.shouldObservableSubscriptionRetry, this.config.observableSubscriptionRetryFunction);
     }
     subscribeOperation(filter) {
-        return new ObservableSubscription(this.newBlock$.pipe(applyFilter(filter)), this.context.config.shouldObservableSubscriptionRetry, this.context.config.observableSubscriptionRetryFunction);
+        return new ObservableSubscription(this.newBlock$.pipe(applyFilter(filter)), this.config.shouldObservableSubscriptionRetry, this.config.observableSubscriptionRetryFunction);
+    }
+}
+
+class TaquitoLocalForger {
+    constructor(context) {
+        this.context = context;
+    }
+    getNextProto() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.context.proto) {
+                const nextProto = yield this.context.readProvider.getNextProtocol('head');
+                this.context.proto = nextProto;
+            }
+            return this.context.proto;
+        });
+    }
+    forge({ branch, contents }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const forger = new LocalForger(yield this.getNextProto());
+            return forger.forge({ branch, contents });
+        });
+    }
+}
+
+const defaultConfigConfirmation = {
+    defaultConfirmationCount: 1,
+    confirmationPollingTimeoutSecond: 180,
+};
+/**
+ * @description Encapsulate common service used throughout different part of the library
+ */
+class Context {
+    constructor(_rpc, _signer = new NoopSigner(), _proto, _config = new BehaviorSubject(Object.assign({}, defaultConfigConfirmation)), forger, injector, packer, wallet, parser, globalConstantsProvider, readProvider, stream) {
+        this._rpc = _rpc;
+        this._signer = _signer;
+        this._proto = _proto;
+        this._config = _config;
+        this.providerDecorator = [];
+        this.tz = new RpcTzProvider(this);
+        this.estimate = new RPCEstimateProvider(this);
+        this.contract = new RpcContractProvider(this, this.estimate);
+        this.batch = new RPCBatchProvider(this, this.estimate);
+        this.wallet = new Wallet(this);
+        /**
+         * @description Applies the decorators on a cloned instance of the context and returned this cloned instance.
+         * The decorators are functions that inject logic into the context.
+         * They are provided by the extensions set on the TezosToolkit by calling the registerProviderDecorator method.
+         */
+        this.withExtensions = () => {
+            let clonedContext = this.clone();
+            this.providerDecorator.forEach((decorator) => {
+                clonedContext = decorator(clonedContext);
+            });
+            return clonedContext;
+        };
+        if (typeof this._rpc === 'string') {
+            this._rpcClient = new RpcClient(this._rpc);
+        }
+        else {
+            this._rpcClient = this._rpc;
+        }
+        this._forger = forger ? forger : new TaquitoLocalForger(this);
+        this._injector = injector ? injector : new RpcInjector(this);
+        this.operationFactory = new OperationFactory(this);
+        this._walletProvider = wallet ? wallet : new LegacyWalletProvider(this);
+        this._parser = parser ? parser : new MichelCodecParser(this);
+        this._packer = packer ? packer : new RpcPacker(this);
+        this._globalConstantsProvider = globalConstantsProvider
+            ? globalConstantsProvider
+            : new NoopGlobalConstantsProvider();
+        this._readProvider = readProvider ? readProvider : new RpcReadAdapter(this);
+        this._stream = stream ? stream : new PollingSubscribeProvider(this);
+    }
+    get config() {
+        return this._config.getValue();
+    }
+    set config(value) {
+        this._config.next(Object.assign({}, value));
+    }
+    setPartialConfig(value) {
+        this._config.next(Object.assign(Object.assign({}, this._config.getValue()), value));
+    }
+    get rpc() {
+        return this._rpcClient;
+    }
+    set rpc(value) {
+        this._rpcClient = value;
+    }
+    get injector() {
+        return this._injector;
+    }
+    set injector(value) {
+        this._injector = value;
+    }
+    get forger() {
+        return this._forger;
+    }
+    set forger(value) {
+        this._forger = value;
+    }
+    get signer() {
+        return this._signer;
+    }
+    set signer(value) {
+        this._signer = value;
+    }
+    get walletProvider() {
+        return this._walletProvider;
+    }
+    set walletProvider(value) {
+        this._walletProvider = value;
+    }
+    set proto(value) {
+        this._proto = value;
+    }
+    get proto() {
+        return this._proto;
+    }
+    get parser() {
+        return this._parser;
+    }
+    set parser(value) {
+        this._parser = value;
+    }
+    get packer() {
+        return this._packer;
+    }
+    set packer(value) {
+        this._packer = value;
+    }
+    get globalConstantsProvider() {
+        return this._globalConstantsProvider;
+    }
+    set globalConstantsProvider(value) {
+        this._globalConstantsProvider = value;
+    }
+    get readProvider() {
+        return this._readProvider;
+    }
+    set readProvider(value) {
+        this._readProvider = value;
+    }
+    get stream() {
+        return this._stream;
+    }
+    set stream(value) {
+        this._stream = value;
+    }
+    isAnyProtocolActive(protocol = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._proto) {
+                return protocol.includes(this._proto);
+            }
+            else {
+                const next_protocol = yield this.readProvider.getNextProtocol('head');
+                return protocol.includes(next_protocol);
+            }
+        });
+    }
+    isAnySignerConfigured() {
+        return !(this.signer instanceof NoopSigner);
+    }
+    /**
+     * @description Create a copy of the current context. Useful when you have long running operation and you do not want a context change to affect the operation
+     */
+    clone() {
+        return new Context(this.rpc, this.signer, this.proto, this._config, this.forger, this._injector, this.packer, this._walletProvider, this._parser, this._globalConstantsProvider, this._readProvider, this._stream);
+    }
+    /**
+     * @description Allows extensions set on the TezosToolkit to inject logic into the context
+     */
+    registerProviderDecorator(fx) {
+        this.providerDecorator.push(fx);
     }
 }
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "81f0a5b103f867f57fbe5d526315c375a3788346",
-    "version": "11.2.0"
+    "commitHash": "5da8cec9c84c0ab7bc37c0eb09e68db1b3a8b1f0",
+    "version": "12.0.0-beta-RC.0"
 };
 
 class ForgingMismatchError extends Error {
@@ -4273,6 +4207,15 @@ class CompositeForger {
     }
 }
 
+class RpcForger {
+    constructor(context) {
+        this.context = context;
+    }
+    forge({ branch, contents }) {
+        return this.context.rpc.forgeOperations({ branch, contents });
+    }
+}
+
 class NoopParser {
     prepareCodeOrigination(params) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -4323,6 +4266,110 @@ class DefaultGlobalConstantsProvider {
     }
 }
 
+/**
+ * @description Naïve implementation of an estimate provider. Will work for basic transaction but your operation risk to fail if they are more complex (smart contract interaction)
+ *
+ * @deprecated Deprecated in favor of RPCEstimateProvider
+ */
+class NaiveEstimateProvider {
+    constructor(protocol) {
+        this.protocol = protocol;
+        this._costPerByte = 250;
+    }
+    registerGlobalConstant(params) {
+        throw new Error(`Unsupported operation kind: ${params.kind}`);
+    }
+    /**
+     *
+     * @description Estimate gasLimit, storageLimit and fees for an origination operation
+     *
+     * @returns An estimation of gasLimit, storageLimit and fees for the operation
+     *
+     * @param OriginationOperation Originate operation parameter
+     */
+    originate({ fee = DEFAULT_FEE.ORIGINATION, storageLimit = DEFAULT_STORAGE_LIMIT.ORIGINATION, gasLimit = DEFAULT_GAS_LIMIT.ORIGINATION * 1000, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Estimate(gasLimit, storageLimit, 185, this._costPerByte, fee);
+        });
+    }
+    /**
+     *
+     * @description Estimate gasLimit, storageLimit and fees for an transfer operation
+     *
+     * @returns An estimation of gasLimit, storageLimit and fees for the operation
+     *
+     * @param TransferOperation Originate operation parameter
+     */
+    transfer({ fee = DEFAULT_FEE.TRANSFER, storageLimit = DEFAULT_STORAGE_LIMIT.TRANSFER, gasLimit = DEFAULT_GAS_LIMIT.TRANSFER * 1000, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Estimate(gasLimit, storageLimit, 162, this._costPerByte, fee);
+        });
+    }
+    /**
+     *
+     * @description Estimate gasLimit, storageLimit and fees for a delegate operation
+     *
+     * @returns An estimation of gasLimit, storageLimit and fees for the operation
+     *
+     * @param Estimate
+     */
+    setDelegate({ fee = DEFAULT_FEE.DELEGATION, gasLimit = DEFAULT_GAS_LIMIT.DELEGATION * 1000, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Estimate(gasLimit, 0, 157, this._costPerByte, fee);
+        });
+    }
+    /**
+     *
+     * @description Estimate gasLimit, storageLimit and fees for a delegate operation
+     *
+     * @returns An estimation of gasLimit, storageLimit and fees for the operation
+     *
+     * @param Estimate
+     */
+    registerDelegate({ fee = DEFAULT_FEE.DELEGATION, gasLimit = DEFAULT_GAS_LIMIT.DELEGATION * 1000, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Estimate(gasLimit, 0, 157, this._costPerByte, fee);
+        });
+    }
+    /**
+     *
+     * @description Estimate gasLimit, storageLimit and fees for a reveal operation
+     *
+     * @returns An estimation of gasLimit, storageLimit and fees for the operation
+     *
+     * @param Estimate
+     */
+    reveal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Estimate(DEFAULT_GAS_LIMIT.REVEAL * 1000, DEFAULT_STORAGE_LIMIT.REVEAL, 64, this._costPerByte, DEFAULT_FEE.REVEAL);
+        });
+    }
+    batch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const estimates = [];
+            for (const param of params) {
+                switch (param.kind) {
+                    case 'transaction':
+                        estimates.push(yield this.transfer(param));
+                        break;
+                    case 'origination':
+                        estimates.push(yield this.originate(param));
+                        break;
+                    case 'delegation':
+                        estimates.push(yield this.setDelegate(param));
+                        break;
+                    case 'activate_account':
+                        estimates.push(new Estimate(0, 0, 0, this._costPerByte, 0));
+                        break;
+                    default:
+                        throw new Error(`Unsupported operation kind: ${param.kind}`);
+                }
+            }
+            return estimates;
+        });
+    }
+}
+
 /**
  * @packageDocumentation
  * @module @taquito/taquito
@@ -4357,7 +4404,7 @@ class TezosToolkit {
      * @example Tezos.setProvider({ config: { confirmationPollingTimeoutSecond: 300 }})
      *
      */
-    setProvider({ rpc, stream, signer, protocol, config, forger, wallet, packer, globalConstantsProvider, }) {
+    setProvider({ rpc, stream, signer, protocol, config, forger, wallet, packer, globalConstantsProvider, readProvider, }) {
         this.setRpcProvider(rpc);
         this.setStreamProvider(stream);
         this.setSignerProvider(signer);
@@ -4365,6 +4412,7 @@ class TezosToolkit {
         this.setWalletProvider(wallet);
         this.setPackerProvider(packer);
         this.setGlobalConstantsProvider(globalConstantsProvider);
+        this.setReadProvider(readProvider);
         this._context.proto = protocol;
         if (config) {
             this._context.setPartialConfig(config);
@@ -4409,16 +4457,23 @@ class TezosToolkit {
     }
     /**
      * @description Sets forger provider on the Tezos Taquito instance
+     * The `LocalForger` from `@taquito/local-forging` is set by default.
      *
      * @param options forger to use to interact with the Tezos network
      *
-     * @example Tezos.setForgerProvider(localForger)
+     * @example Tezos.setForgerProvider(this.getFactory(RpcForger)())
      *
      */
     setForgerProvider(forger) {
-        const f = typeof forger === 'undefined' ? this.getFactory(RpcForger)() : forger;
-        this._options.forger = f;
-        this._context.forger = f;
+        if (typeof forger !== 'undefined') {
+            this._options.forger = forger;
+            this._context.forger = forger;
+        }
+        else if (this._options.forger === undefined) {
+            const f = this.getFactory(TaquitoLocalForger)();
+            this._options.forger = f;
+            this._context.forger = f;
+        }
     }
     /**
      * @description Sets stream provider on the Tezos Taquito instance
@@ -4430,15 +4485,19 @@ class TezosToolkit {
      */
     setStreamProvider(stream) {
         if (typeof stream === 'string') {
-            this._stream = new PollingSubscribeProvider(new Context(new RpcClient(stream)));
+            const s = new PollingSubscribeProvider(new Context(new RpcClient(stream)));
+            this._options.stream = s;
+            this._context.stream = s;
         }
         else if (typeof stream !== 'undefined') {
-            this._stream = stream;
+            this._options.stream = stream;
+            this._context.stream = stream;
         }
         else if (this._options.stream === undefined) {
-            this._stream = this.getFactory(PollingSubscribeProvider)();
+            const s = this.getFactory(PollingSubscribeProvider)();
+            this._options.stream = s;
+            this._context.stream = s;
         }
-        this._options.stream = stream;
     }
     /**
      * @description Sets wallet provider on the Tezos Taquito instance
@@ -4468,9 +4527,15 @@ class TezosToolkit {
      *
      */
     setPackerProvider(packer) {
-        const p = typeof packer === 'undefined' ? this.getFactory(RpcPacker)() : packer;
-        this._options.packer = p;
-        this._context.packer = p;
+        if (!this._options.packer && typeof packer === 'undefined') {
+            const p = this.getFactory(RpcPacker)();
+            this._context.packer = p;
+            this._options.packer = p;
+        }
+        else if (typeof packer !== 'undefined') {
+            this._context.packer = packer;
+            this._options.packer = packer;
+        }
     }
     /**
      * @description Sets global constants provider on the Tezos Taquito instance
@@ -4489,11 +4554,27 @@ class TezosToolkit {
      *
      */
     setGlobalConstantsProvider(globalConstantsProvider) {
-        const g = typeof globalConstantsProvider === 'undefined'
-            ? new NoopGlobalConstantsProvider()
-            : globalConstantsProvider;
-        this._options.globalConstantsProvider = g;
-        this._context.globalConstantsProvider = g;
+        if (!this._options.globalConstantsProvider && typeof globalConstantsProvider === 'undefined') {
+            const g = new NoopGlobalConstantsProvider();
+            this._context.globalConstantsProvider = g;
+            this._options.globalConstantsProvider = g;
+        }
+        else if (typeof globalConstantsProvider !== 'undefined') {
+            this._context.globalConstantsProvider = globalConstantsProvider;
+            this._options.globalConstantsProvider = globalConstantsProvider;
+        }
+    }
+    /**
+     * @description Sets read provider on the Tezos Taquito instance
+     * By default reads are done from the RPC usign the RpcReadAdapter class, this can be overridden to read from an indexer that implements the TzReadProvider interface
+     *
+     * @param options TzReadProvider to use to interact with the Tezos network
+     *
+     */
+    setReadProvider(readProvider) {
+        const readP = typeof readProvider === 'undefined' ? this.getFactory(RpcReadAdapter)() : readProvider;
+        this._options.readProvider = readP;
+        this._context.readProvider = readP;
     }
     /**
      * @description Provide access to tezos account management
@@ -4523,7 +4604,7 @@ class TezosToolkit {
      * @description Provide access to streaming utilities backed by an streamer implementation
      */
     get stream() {
-        return this._stream;
+        return this._context.stream;
     }
     /**
      * @description Provide access to the currently used rpc client
@@ -4571,5 +4652,5 @@ class TezosToolkit {
     }
 }
 
-export { BatchOperation, BigMapAbstraction, ChainIds, CompositeForger, Context, ContractAbstraction, ContractMethod, ContractMethodObject, ContractView, DEFAULT_FEE, DEFAULT_GAS_LIMIT, DEFAULT_SMART_CONTRACT_METHOD_NAME, DEFAULT_STORAGE_LIMIT, DefaultGlobalConstantsProvider, DefaultLambdaAddresses, DelegateOperation, DelegationWalletOperation, GlobalConstantNotFound, InvalidCodeParameter, InvalidDelegationSource, InvalidInitParameter, InvalidParameterError, InvalidViewParameterError, InvalidViewSimulationContext, LegacyWalletProvider, MANAGER_LAMBDA, MichelCodecPacker, MichelCodecParser, MissedBlockDuringConfirmationError, NoopParser, ObservableSubscription, Operation, OperationBatch, OriginationOperation, OriginationWalletOperation, PollingSubscribeProvider, Protocols, RpcForger, RpcPacker, TezosOperationError, TezosPreapplyFailureError, TezosToolkit, TransactionOperation, TransactionWalletOperation, UnconfiguredGlobalConstantsProviderError, UndefinedLambdaContractError, VIEW_LAMBDA, ViewSimulationError, Wallet, WalletOperation, WalletOperationBatch, compose, createOriginationOperation, createRegisterDelegateOperation, createRegisterGlobalConstantOperation, createRevealOperation, createSetDelegateOperation, createTransferOperation, defaultConfigConfirmation, defaultConfigStreamer, protocols, validateAndExtractFailwith };
+export { BatchOperation, BigMapAbstraction, ChainIds, CompositeForger, Context, ContractAbstraction, ContractMethod, ContractMethodObject, ContractView, DEFAULT_FEE, DEFAULT_GAS_LIMIT, DEFAULT_SMART_CONTRACT_METHOD_NAME, DEFAULT_STORAGE_LIMIT, DefaultGlobalConstantsProvider, DelegateOperation, DelegationWalletOperation, Estimate, GlobalConstantNotFound, InvalidCodeParameter, InvalidDelegationSource, InvalidInitParameter, InvalidParameterError, InvalidViewParameterError, InvalidViewSimulationContext, LegacyWalletProvider, MANAGER_LAMBDA, MichelCodecPacker, MichelCodecParser, MissedBlockDuringConfirmationError, NaiveEstimateProvider, NoopParser, ObservableSubscription, Operation, OperationBatch, OriginationOperation, OriginationWalletOperation, PollingSubscribeProvider, Protocols, RPCEstimateProvider, RevealEstimateError, RpcForger, RpcPacker, RpcReadAdapter, TezosOperationError, TezosPreapplyFailureError, TezosToolkit, TransactionOperation, TransactionWalletOperation, UnconfiguredGlobalConstantsProviderError, UndefinedLambdaContractError, VIEW_LAMBDA, ViewSimulationError, Wallet, WalletOperation, WalletOperationBatch, compose, createOriginationOperation, createRegisterDelegateOperation, createRegisterGlobalConstantOperation, createRevealOperation, createSetDelegateOperation, createTransferOperation, defaultConfigConfirmation, protocols, validateAndExtractFailwith };
 //# sourceMappingURL=taquito.es6.js.map