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

package/README.md

@@ -10,6 +10,7 @@ _Documentation can be found [here](https://taquito.io/docs/walletconnect)_
 
 `@taquito/wallet-connect` is an npm package that provides developers a way to connect a dapp built with Taquito to a wallet giving the freedom to the users of the dapp to choose the wallet via the WalletConnect/Reown protocol. The `WalletConnect` class implements the `WalletProvider` interface, providing an alternative to `BeaconWallet`.
 Note: Currently, a QR code is displayed to establish a connection with a wallet. As more Tezos wallets integrate with WalletConnect, we plan showing a list of available wallets alongside the QR code.
+Note: The current QR pairing flow still relies on the legacy WalletConnect modal package. We plan to replace that modal integration in a future release.
 
 ## Install
 
@@ -39,7 +40,7 @@ const wallet = await WalletConnect.init({
 
 await wallet.requestPermissions({
     permissionScope: {
-        networks: [NetworkType.GHOSTNET],
+        networks: [NetworkType.SHADOWNET],
         events: [],
         methods: [
             PermissionScopeMethods.TEZOS_SEND,
@@ -53,6 +54,8 @@ const Tezos = new TezosToolkit('https://YOUR_PREFERRED_RPC_URL');
 Tezos.setWalletProvider(wallet);
 ```
 
+Existing sessions can be restored with `configureWithExistingSessionKey()`. Restored sessions are validated before activation, so invalid or stale non-Tezos session data may be rejected during restore.
+
 ## Additional Info
 
 See the top-level [https://github.com/ecadlabs/taquito](https://github.com/ecadlabs/taquito) file for details on reporting issues, contributing and versioning.

package/dist/lib/taquito/src/batch/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BATCH_KINDS = void 0;
+const rpc_1 = require("@taquito/rpc");
+exports.BATCH_KINDS = [
+    rpc_1.OpKind.ACTIVATION,
+    rpc_1.OpKind.ORIGINATION,
+    rpc_1.OpKind.TRANSACTION,
+    rpc_1.OpKind.DELEGATION,
+    rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT,
+    rpc_1.OpKind.INCREASE_PAID_STORAGE,
+    rpc_1.OpKind.TRANSFER_TICKET,
+    rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES,
+    rpc_1.OpKind.SMART_ROLLUP_ORIGINATE,
+    rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE,
+];

package/dist/lib/taquito/src/batch/rpc-batch-provider.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPCBatchProvider = exports.OperationBatch = exports.BATCH_KINDS = void 0;
+const prepare_1 = require("../contract/prepare");
+const batch_operation_1 = require("../operations/batch-operation");
+const rpc_1 = require("@taquito/rpc");
+const utils_1 = require("@taquito/utils");
+const core_1 = require("@taquito/core");
+const provider_1 = require("../provider");
+const prepare_2 = require("../prepare");
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "BATCH_KINDS", { enumerable: true, get: function () { return constants_1.BATCH_KINDS; } });
+class OperationBatch extends provider_1.Provider {
+    constructor(context, estimator) {
+        super(context);
+        this.estimator = estimator;
+        this.operations = [];
+        this.prepare = new prepare_2.PrepareProvider(this.context);
+    }
+    /**
+     *
+     * Add a transaction operation to the batch
+     *
+     * @param params Transfer operation parameter
+     */
+    withTransfer(params) {
+        const toValidation = (0, utils_1.validateAddress)(params.to);
+        if (params.amount < 0) {
+            throw new core_1.InvalidAmountError(params.amount.toString());
+        }
+        if (toValidation !== utils_1.ValidationResult.VALID) {
+            throw new core_1.InvalidAddressError(params.to, toValidation);
+        }
+        this.operations.push({ kind: rpc_1.OpKind.TRANSACTION, ...params });
+        return this;
+    }
+    /**
+     *
+     * Transfer tickets from a Tezos address (tz1,tz2 or tz3) to a smart contract address( KT1)
+     *
+     * @param params Transfer operation parameter
+     */
+    withTransferTicket(params) {
+        const destinationValidation = (0, utils_1.validateAddress)(params.destination);
+        if (destinationValidation !== utils_1.ValidationResult.VALID) {
+            throw new core_1.InvalidAddressError(params.destination, destinationValidation);
+        }
+        this.operations.push({ kind: rpc_1.OpKind.TRANSFER_TICKET, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add a contract call to the batch
+     *
+     * @param params Call a contract method
+     * @param options Generic operation parameters
+     */
+    withContractCall(params, options = {}) {
+        return this.withTransfer(params.toTransferParams(options));
+    }
+    /**
+     *
+     * Add a delegation operation to the batch
+     *
+     * @param params Delegation operation parameter
+     */
+    withDelegation(params) {
+        const sourceValidation = (0, utils_1.validateAddress)(params.source ?? '');
+        if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
+            throw new core_1.InvalidAddressError(params.source, sourceValidation);
+        }
+        const delegateValidation = (0, utils_1.validateAddress)(params.delegate ?? '');
+        if (params.delegate && delegateValidation !== utils_1.ValidationResult.VALID) {
+            throw new core_1.InvalidAddressError(params.delegate, delegateValidation);
+        }
+        this.operations.push({ kind: rpc_1.OpKind.DELEGATION, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add an activation operation to the batch
+     *
+     * @param params Activation operation parameter
+     * @throws InvalidKeyHashError
+     */
+    withActivation({ pkh, secret }) {
+        const pkhValidation = (0, utils_1.validateKeyHash)(pkh);
+        if (pkhValidation !== utils_1.ValidationResult.VALID) {
+            throw new core_1.InvalidKeyHashError(pkh, pkhValidation);
+        }
+        this.operations.push({ kind: rpc_1.OpKind.ACTIVATION, pkh, secret });
+        return this;
+    }
+    /**
+     *
+     * Add an origination operation to the batch
+     *
+     * @param params Origination operation parameter
+     */
+    withOrigination(params) {
+        this.operations.push({ kind: rpc_1.OpKind.ORIGINATION, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add a register a global constant operation to the batch
+     *
+     * @param params RegisterGlobalConstant operation parameter
+     */
+    withRegisterGlobalConstant(params) {
+        this.operations.push({ kind: rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add an increase paid storage operation to the batch
+     *
+     * @param params IncreasePaidStorage operation parameter
+     */
+    withIncreasePaidStorage(params) {
+        this.operations.push({ kind: rpc_1.OpKind.INCREASE_PAID_STORAGE, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add a update consensus key operation to the batch
+     *
+     * @param params UpdateConsensusKey operation parameter
+     */
+    withUpdateConsensusKey(params) {
+        const [, pkPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(params.pk, utils_1.publicKeyPrefixes);
+        if (pkPrefix === utils_1.PrefixV2.BLS12_381PublicKey) {
+            if (!params.proof) {
+                throw new core_1.InvalidProofError('Proof is required to set a bls account as consensus key ');
+            }
+        }
+        else {
+            if (params.proof) {
+                throw new core_1.ProhibitedActionError('Proof field is only allowed for a bls account as consensus key');
+            }
+        }
+        this.operations.push({ kind: rpc_1.OpKind.UPDATE_CONSENSUS_KEY, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add a update companion key operation to the batch
+     *
+     * @param params UpdateCompanionKey operation parameter
+     */
+    withUpdateCompanionKey(params) {
+        const [, pkPrefix] = (0, utils_1.b58DecodeAndCheckPrefix)(params.pk, utils_1.publicKeyPrefixes);
+        if (pkPrefix !== utils_1.PrefixV2.BLS12_381PublicKey) {
+            throw new core_1.ProhibitedActionError('companion key must be a bls account');
+        }
+        if (!params.proof) {
+            throw new core_1.InvalidProofError('Proof is required to set a bls account as companion key ');
+        }
+        this.operations.push({ kind: rpc_1.OpKind.UPDATE_COMPANION_KEY, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add a smart rollup add messages operation to the batch
+     *
+     * @param params Rollup origination operation parameter
+     */
+    withSmartRollupAddMessages(params) {
+        this.operations.push({ kind: rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add a smart rollup originate operation to the batch
+     *
+     * @param params Smart Rollup Originate operation parameter
+     */
+    withSmartRollupOriginate(params) {
+        this.operations.push({ kind: rpc_1.OpKind.SMART_ROLLUP_ORIGINATE, ...params });
+        return this;
+    }
+    /**
+     *
+     * Add a smart rollup execute outbox message to the batch
+     *
+     * @param params Smart Rollup Execute Outbox Message operation parameter
+     */
+    withSmartRollupExecuteOutboxMessage(params) {
+        this.operations.push({ kind: rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE, ...params });
+        return this;
+    }
+    async getRPCOp(param) {
+        switch (param.kind) {
+            case rpc_1.OpKind.TRANSACTION:
+                return (0, prepare_1.createTransferOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.ORIGINATION:
+                return (0, prepare_1.createOriginationOperation)(await this.context.parser.prepareCodeOrigination({
+                    ...param,
+                }));
+            case rpc_1.OpKind.DELEGATION:
+                return (0, prepare_1.createSetDelegateOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT:
+                return (0, prepare_1.createRegisterGlobalConstantOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.INCREASE_PAID_STORAGE:
+                return (0, prepare_1.createIncreasePaidStorageOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.UPDATE_CONSENSUS_KEY:
+                return (0, prepare_1.createUpdateConsensusKeyOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.UPDATE_COMPANION_KEY:
+                return (0, prepare_1.createUpdateCompanionKeyOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.TRANSFER_TICKET:
+                return (0, prepare_1.createTransferTicketOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES:
+                return (0, prepare_1.createSmartRollupAddMessagesOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.SMART_ROLLUP_ORIGINATE:
+                return (0, prepare_1.createSmartRollupOriginateOperation)({
+                    ...param,
+                });
+            case rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE:
+                return (0, prepare_1.createSmartRollupExecuteOutboxMessageOperation)({
+                    ...param,
+                });
+            default:
+                throw new core_1.InvalidOperationKindError(JSON.stringify(param.kind));
+        }
+    }
+    /**
+     *
+     * Add a group operation to the batch. Operation will be applied in the order they are in the params array
+     *
+     * @param params Operations parameter
+     * @throws InvalidOperationKindError
+     */
+    with(params) {
+        for (const param of params) {
+            switch (param.kind) {
+                case rpc_1.OpKind.TRANSACTION:
+                    this.withTransfer(param);
+                    break;
+                case rpc_1.OpKind.ORIGINATION:
+                    this.withOrigination(param);
+                    break;
+                case rpc_1.OpKind.DELEGATION:
+                    this.withDelegation(param);
+                    break;
+                case rpc_1.OpKind.ACTIVATION:
+                    this.withActivation(param);
+                    break;
+                case rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT:
+                    this.withRegisterGlobalConstant(param);
+                    break;
+                case rpc_1.OpKind.INCREASE_PAID_STORAGE:
+                    this.withIncreasePaidStorage(param);
+                    break;
+                case rpc_1.OpKind.TRANSFER_TICKET:
+                    this.withTransferTicket(param);
+                    break;
+                case rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES:
+                    this.withSmartRollupAddMessages(param);
+                    break;
+                case rpc_1.OpKind.SMART_ROLLUP_ORIGINATE:
+                    this.withSmartRollupOriginate(param);
+                    break;
+                case rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE:
+                    this.withSmartRollupExecuteOutboxMessage(param);
+                    break;
+                default:
+                    throw new core_1.InvalidOperationKindError(JSON.stringify(param.kind));
+            }
+        }
+        return this;
+    }
+    /**
+     *
+     * Forge and Inject the operation batch
+     *
+     * @param params Optionally specify the source of the operation
+     */
+    async send(params) {
+        const publicKeyHash = await this.signer.publicKeyHash();
+        const source = (params && params.source) || publicKeyHash;
+        const estimates = await this.estimator.batch(this.operations);
+        if (estimates.length !== this.operations.length) {
+            estimates.shift();
+        }
+        const preparedOp = await this.prepare.batch(this.operations, estimates);
+        const opBytes = await this.forge(preparedOp);
+        const { hash, context, forgedBytes, opResponse } = await this.signAndInject(opBytes);
+        return new batch_operation_1.BatchOperation(hash, preparedOp.opOb.contents, source, forgedBytes, opResponse, context);
+    }
+}
+exports.OperationBatch = OperationBatch;
+class RPCBatchProvider {
+    constructor(context, estimator) {
+        this.context = context;
+        this.estimator = estimator;
+    }
+    /***
+     *
+     * Batch a group of operation together. Operations will be applied in the order in which they are added to the batch
+     *
+     * @param params List of operation to batch together
+     */
+    batch(params) {
+        const batch = new OperationBatch(this.context, this.estimator);
+        if (Array.isArray(params)) {
+            batch.with(params);
+        }
+        return batch;
+    }
+}
+exports.RPCBatchProvider = RPCBatchProvider;

package/dist/lib/taquito/src/constants.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRevealFeeInternal = exports.getRevealFee = exports.getRevealGasLimit = exports.ChainIds = exports.protocols = exports.Protocols = exports.COST_PER_BYTE = exports.ORIGINATION_SIZE = exports.REVEAL_STORAGE_LIMIT = void 0;
+// value is based on octez-client reveal operation gasLimit of each address type in Tallinn Protocol
+const REVEAL_GAS_LIMIT = {
+    TZ1: 171,
+    TZ2: 157,
+    TZ3: 447,
+    TZ4: 3252,
+};
+// value is based on octez-client reveal operation fee of each address type in Tallinn Protocol
+const REVEAL_FEE = {
+    TZ1: 278,
+    TZ2: 277,
+    TZ3: 306,
+    TZ4: 736,
+};
+// value is based on octez-client reveal operation storageLimit of all address type in Tallinn Protocol
+exports.REVEAL_STORAGE_LIMIT = 0;
+// protocol constants in Tallinn Protocol
+// NOTE: When updating constants here, also check:
+//   website/src/config/tezos-constants.mjs (documentation constants, versioned by doc version)
+exports.ORIGINATION_SIZE = 257;
+// protocol constants in Tallinn Protocol
+exports.COST_PER_BYTE = 250;
+var Protocols;
+(function (Protocols) {
+    Protocols["Pt24m4xi"] = "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd";
+    Protocols["PsBABY5H"] = "PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU";
+    Protocols["PsBabyM1"] = "PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS";
+    Protocols["PsCARTHA"] = "PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb";
+    Protocols["PsDELPH1"] = "PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo";
+    Protocols["PtEdo2Zk"] = "PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA";
+    Protocols["PsFLorena"] = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i";
+    Protocols["PtGRANADs"] = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV";
+    Protocols["PtHangz2"] = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx";
+    Protocols["PsiThaCa"] = "PsiThaCaT47Zboaw71QWScM8sXeMM7bbQFncK9FLqYc6EKdpjVP";
+    Protocols["Psithaca2"] = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A";
+    Protocols["PtJakart2"] = "PtJakart2xVj7pYXJBXrqHgd82rdkLey5ZeeGwDgPp9rhQUbSqY";
+    Protocols["PtKathman"] = "PtKathmankSpLLDALzWw7CGD2j2MtyveTwboEYokqUCP4a1LxMg";
+    Protocols["PtLimaPtL"] = "PtLimaPtLMwfNinJi9rCfDPWea8dFgTZ1MeJ9f1m2SRic6ayiwW";
+    Protocols["PtMumbaii"] = "PtMumbaiiFFEGbew1rRjzSPyzRbA51Tm3RVZL5suHPxSZYDhCEc";
+    Protocols["PtMumbai2"] = "PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1";
+    Protocols["PtNairobi"] = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf";
+    Protocols["ProxfordY"] = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH";
+    Protocols["PtParisBx"] = "PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ";
+    Protocols["PsParisCZ"] = "PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi";
+    Protocols["PsQuebecn"] = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg";
+    Protocols["PsRiotuma"] = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7";
+    Protocols["PtSeouLou"] = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh";
+    Protocols["PtTALLiNt"] = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu";
+    Protocols["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
+})(Protocols || (exports.Protocols = Protocols = {}));
+exports.protocols = {
+    '004': [Protocols.Pt24m4xi],
+    '005': [Protocols.PsBABY5H, Protocols.PsBabyM1],
+    '006': [Protocols.PsCARTHA],
+    '007': [Protocols.PsDELPH1],
+    '008': [Protocols.PtEdo2Zk], // edonet v2
+    '009': [Protocols.PsFLorena],
+    '010': [Protocols.PtGRANADs],
+    '011': [Protocols.PtHangz2], // hangzhou v2,
+    '012': [Protocols.PsiThaCa, Protocols.Psithaca2],
+    '013': [Protocols.PtJakart2],
+    '014': [Protocols.PtKathman],
+    '015': [Protocols.PtLimaPtL],
+    '016': [Protocols.PtMumbai2], // mumbai v2
+    '017': [Protocols.PtNairobi],
+    '019': [Protocols.ProxfordY],
+    '020': [Protocols.PtParisBx, Protocols.PsParisCZ],
+    '021': [Protocols.PsQuebecn],
+    '022': [Protocols.PsRiotuma],
+    '023': [Protocols.PtSeouLou],
+    '024': [Protocols.PtTALLiNt],
+    '025': [Protocols.ProtoALpha],
+};
+var ChainIds;
+(function (ChainIds) {
+    ChainIds["MAINNET"] = "NetXdQprcVkpaWU";
+    ChainIds["GHOSTNET"] = "NetXnHfVqm9iesp";
+    ChainIds["SHADOWNET"] = "NetXsqzbfFenSTS";
+    ChainIds["CARTHAGENET"] = "NetXjD3HPJJjmcd";
+    ChainIds["DELPHINET"] = "NetXm8tYqnMWky1";
+    ChainIds["EDONET"] = "NetXSgo1ZT2DRUG";
+    ChainIds["FLORENCENET"] = "NetXxkAx4woPLyu";
+    ChainIds["GRANADANET"] = "NetXz969SFaFn8k";
+    ChainIds["HANGZHOUNET"] = "NetXZSsxBpMQeAT";
+    ChainIds["ITHACANET"] = "NetXbhmtAbMukLc";
+    ChainIds["JAKARTANET2"] = "NetXLH1uAxK7CCh";
+    ChainIds["KATHMANDUNET"] = "NetXazhm4yetmff";
+    ChainIds["LIMANET"] = "NetXizpkH94bocH";
+    ChainIds["MUMBAINET"] = "NetXQw6nWSnrJ5t";
+    ChainIds["MUMBAINET2"] = "NetXgbcrNtXD2yA";
+    ChainIds["NAIROBINET"] = "NetXyuzvDo2Ugzb";
+    ChainIds["OXFORDNET2"] = "NetXxWsskGahzQB";
+    ChainIds["PARISBNET"] = "NetXo8SqH1c38SS";
+    ChainIds["PARISCNET"] = "NetXXWAHLEvre9b";
+    ChainIds["QUEBECNET"] = "NetXuTeGinLEqxp";
+    ChainIds["RIONET"] = "NetXPdgaoabtBth";
+    ChainIds["SEOULNET"] = "NetXd56aBs1aeW3";
+    ChainIds["TALLINNNET"] = "NetXe8DbhW9A1eS";
+})(ChainIds || (exports.ChainIds = ChainIds = {}));
+const getRevealGasLimit = (address) => Math.round((getRevealGasLimitInternal(address) * 37) / 10);
+exports.getRevealGasLimit = getRevealGasLimit;
+const getRevealGasLimitInternal = (address) => {
+    switch (address.substring(0, 3)) {
+        case 'tz1':
+            return REVEAL_GAS_LIMIT.TZ1;
+        case 'tz2':
+            return REVEAL_GAS_LIMIT.TZ2;
+        case 'tz3':
+            return REVEAL_GAS_LIMIT.TZ3;
+        case 'tz4':
+            return REVEAL_GAS_LIMIT.TZ4;
+        default:
+            throw new Error(`Cannot estimate reveal gas limit for ${address}`);
+    }
+};
+const getRevealFee = (address) => Math.round(((0, exports.getRevealFeeInternal)(address) * 12) / 10);
+exports.getRevealFee = getRevealFee;
+const getRevealFeeInternal = (address) => {
+    switch (address.substring(0, 3)) {
+        case 'tz1':
+            return REVEAL_FEE.TZ1;
+        case 'tz2':
+            return REVEAL_FEE.TZ2;
+        case 'tz3':
+            return REVEAL_FEE.TZ3;
+        case 'tz4':
+            return REVEAL_FEE.TZ4 * 1.7;
+        default:
+            throw new Error(`Cannot estimate reveal fee for ${address}`);
+    }
+};
+exports.getRevealFeeInternal = getRevealFeeInternal;

package/dist/lib/taquito/src/context.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.defaultConfigConfirmation = void 0;
+const rpc_1 = require("@taquito/rpc");
+const rpc_injector_1 = require("./injector/rpc-injector");
+const noop_1 = require("./signer/noop");
+const operation_factory_1 = require("./wallet/operation-factory");
+const rpc_tz_provider_1 = require("./tz/rpc-tz-provider");
+const rpc_estimate_provider_1 = require("./estimate/rpc-estimate-provider");
+const rpc_contract_provider_1 = require("./contract/rpc-contract-provider");
+const rpc_batch_provider_1 = require("./batch/rpc-batch-provider");
+const wallet_1 = require("./wallet");
+const michel_codec_parser_1 = require("./parser/michel-codec-parser");
+const rpc_packer_1 = require("./packer/rpc-packer");
+const rxjs_1 = require("rxjs");
+const noop_global_constants_provider_1 = require("./global-constants/noop-global-constants-provider");
+const rpc_read_adapter_1 = require("./read-provider/rpc-read-adapter");
+const polling_subcribe_provider_1 = require("./subscribe/polling-subcribe-provider");
+const taquito_local_forger_1 = require("./forger/taquito-local-forger");
+const prepare_provider_1 = require("./prepare/prepare-provider");
+exports.defaultConfigConfirmation = {
+    defaultConfirmationCount: 1,
+    confirmationPollingTimeoutSecond: 180,
+};
+/**
+ * Encapsulate common service used throughout different part of the library
+ */
+class Context {
+    constructor(_rpc, _signer = new noop_1.NoopSigner(), _proto, _config = new rxjs_1.BehaviorSubject({
+        ...exports.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 rpc_tz_provider_1.RpcTzProvider(this);
+        this.estimate = new rpc_estimate_provider_1.RPCEstimateProvider(this);
+        this.contract = new rpc_contract_provider_1.RpcContractProvider(this, this.estimate);
+        this.prepare = new prepare_provider_1.PrepareProvider(this);
+        this.batch = new rpc_batch_provider_1.RPCBatchProvider(this, this.estimate);
+        this.wallet = new wallet_1.Wallet(this);
+        /**
+         * 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 rpc_1.RpcClient(this._rpc);
+        }
+        else {
+            this._rpcClient = this._rpc;
+        }
+        this._forger = forger ? forger : new taquito_local_forger_1.TaquitoLocalForger(this);
+        this._injector = injector ? injector : new rpc_injector_1.RpcInjector(this);
+        this.operationFactory = new operation_factory_1.OperationFactory(this);
+        this._walletProvider = wallet ? wallet : new wallet_1.LegacyWalletProvider(this);
+        this._parser = parser ? parser : new michel_codec_parser_1.MichelCodecParser(this);
+        this._packer = packer ? packer : new rpc_packer_1.RpcPacker(this);
+        this._globalConstantsProvider = globalConstantsProvider
+            ? globalConstantsProvider
+            : new noop_global_constants_provider_1.NoopGlobalConstantsProvider();
+        this._readProvider = readProvider ? readProvider : new rpc_read_adapter_1.RpcReadAdapter(this._rpcClient);
+        this._stream = stream ? stream : new polling_subcribe_provider_1.PollingSubscribeProvider(this);
+    }
+    get config() {
+        return this._config.getValue();
+    }
+    set config(value) {
+        this._config.next({
+            ...value,
+        });
+    }
+    setPartialConfig(value) {
+        this._config.next({
+            ...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;
+    }
+    async isAnyProtocolActive(protocol = []) {
+        if (this._proto) {
+            return protocol.includes(this._proto);
+        }
+        else {
+            const next_protocol = await this.readProvider.getNextProtocol('head');
+            return protocol.includes(next_protocol);
+        }
+    }
+    isAnySignerConfigured() {
+        return !(this.signer instanceof noop_1.NoopSigner);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Allows extensions set on the TezosToolkit to inject logic into the context
+     */
+    registerProviderDecorator(fx) {
+        this.providerDecorator.push(fx);
+    }
+}
+exports.Context = Context;