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

package/dist/taquito-wallet-connect.es6.js

@@ -181,18 +181,20 @@ class WalletConnect {
         this.walletConnectModal = WalletConnectModal;
         this.signClient.on('session_delete', ({ topic }) => {
             if (this.session?.topic === topic) {
-                this.session = undefined;
+                this.clearState();
             }
         });
         this.signClient.on('session_expire', ({ topic }) => {
             if (this.session?.topic === topic) {
-                this.session = undefined;
+                this.clearState();
             }
         });
         this.signClient.on('session_update', ({ params, topic }) => {
             if (this.session?.topic === topic) {
-                this.session.namespaces = params.namespaces;
-                // TODO determine if we need validation on the namespace here
+                this.activateSession({
+                    ...this.session,
+                    namespaces: params.namespaces,
+                }, undefined, false);
             }
         });
         this.signClient.on('session_event', () => {
@@ -236,10 +238,11 @@ class WalletConnect {
      */
     async requestPermissions(connectParams) {
         // TODO when Tezos wallets will officially support wallet connect, we need to provide a default value for registryUrl
+        let approvedSession;
         try {
             const chains = connectParams.permissionScope.networks.map((network) => `${TEZOS_PLACEHOLDER}:${network}`);
             const { uri, approval } = await this.signClient.connect({
-                requiredNamespaces: {
+                optionalNamespaces: {
                     [TEZOS_PLACEHOLDER]: {
                         chains,
                         methods: connectParams.permissionScope.methods,
@@ -254,7 +257,7 @@ class WalletConnect {
                     chains,
                 });
             }
-            this.session = await approval();
+            approvedSession = await approval();
         }
         catch (error) {
             throw new ConnectionFailed(error);
@@ -262,8 +265,7 @@ class WalletConnect {
         finally {
             this.walletConnectModal.closeModal();
         }
-        this.validateReceivedNamespace(connectParams.permissionScope, this.session.namespaces);
-        this.setDefaultAccountAndNetwork();
+        this.activateSession(approvedSession, connectParams.permissionScope);
     }
     /**
      * Access all existing active pairings
@@ -288,8 +290,7 @@ class WalletConnect {
         if (!sessions.includes(key)) {
             throw new InvalidSessionKey(key);
         }
-        this.session = this.signClient.session.get(key);
-        this.setDefaultAccountAndNetwork();
+        this.activateSession(this.signClient.session.get(key));
     }
     async disconnect() {
         if (this.session) {
@@ -445,14 +446,28 @@ class WalletConnect {
         }
         return this.activeNetwork;
     }
-    setDefaultAccountAndNetwork() {
-        const activeAccount = this.getAccounts();
-        if (activeAccount.length === 1) {
-            this.activeAccount = activeAccount[0];
+    activateSession(session, permissionScope, resetActiveState = true) {
+        this.session = session;
+        if (permissionScope) {
+            this.validateReceivedNamespace(permissionScope, session.namespaces);
         }
-        const activeNetwork = this.getNetworks();
-        if (activeNetwork.length === 1) {
-            this.activeNetwork = activeNetwork[0];
+        else {
+            this.validateRestoredNamespace(session.namespaces);
+        }
+        if (resetActiveState) {
+            this.activeAccount = undefined;
+            this.activeNetwork = undefined;
+        }
+        this.reconcileActiveAccountAndNetwork();
+    }
+    reconcileActiveAccountAndNetwork() {
+        const accounts = this.getAccounts();
+        if (!this.activeAccount || !accounts.includes(this.activeAccount)) {
+            this.activeAccount = accounts.length === 1 ? accounts[0] : undefined;
+        }
+        const networks = this.getNetworks();
+        if (!this.activeNetwork || !networks.includes(this.activeNetwork)) {
+            this.activeNetwork = networks.length === 1 ? networks[0] : undefined;
         }
     }
     clearState() {
@@ -499,6 +514,14 @@ class WalletConnect {
             throw new InvalidReceivedSessionNamespace('All methods must be approved', getSdkError('USER_REJECTED_METHODS').code, 'incomplete', missingMethods);
         }
     }
+    validateRestoredNamespace(receivedNamespaces) {
+        const tezosNamespace = receivedNamespaces[TEZOS_PLACEHOLDER];
+        if (!tezosNamespace) {
+            this.clearState();
+            throw new InvalidSession('Tezos not found in namespaces');
+        }
+        this.validateAccounts(this.getChainsFromAccounts(tezosNamespace.accounts), tezosNamespace.accounts);
+    }
     validateEvents(requiredEvents, receivedEvents) {
         const missingEvents = [];
         requiredEvents.forEach((method) => {
@@ -516,7 +539,6 @@ class WalletConnect {
             this.clearState();
             throw new InvalidReceivedSessionNamespace('Accounts must not be empty', getSdkError('USER_REJECTED_CHAINS').code, 'incomplete');
         }
-        const receivedChains = [];
         const invalidChains = [];
         const missingChains = [];
         const invalidChainsNamespace = [];
@@ -528,10 +550,6 @@ class WalletConnect {
             if (accountId[0] !== TEZOS_PLACEHOLDER) {
                 invalidChainsNamespace.push(chain);
             }
-            const network = accountId[1];
-            if (!receivedChains.includes(network)) {
-                receivedChains.push(network);
-            }
         });
         if (invalidChains.length > 0) {
             this.clearState();
@@ -541,6 +559,7 @@ class WalletConnect {
             this.clearState();
             throw new InvalidReceivedSessionNamespace('Accounts must be defined in matching namespace', getSdkError('UNSUPPORTED_ACCOUNTS').code, 'invalid', invalidChainsNamespace);
         }
+        const receivedChains = this.getChainsFromAccounts(receivedAccounts);
         requiredNetwork.forEach((network) => {
             if (!receivedChains.includes(network)) {
                 missingChains.push(network);
@@ -559,24 +578,19 @@ class WalletConnect {
             throw new InvalidSession('Tezos not found in namespaces');
         }
     }
-    getTezosRequiredNamespace() {
-        if (TEZOS_PLACEHOLDER in this.getSession().requiredNamespaces) {
-            return this.getSession().requiredNamespaces[TEZOS_PLACEHOLDER];
-        }
-        else {
-            throw new InvalidSession('Tezos not found in requiredNamespaces');
-        }
-    }
     validateNetworkAndAccount(network, account) {
         if (!this.getTezosNamespace().accounts.includes(`${TEZOS_PLACEHOLDER}:${network}:${account}`)) {
             throw new InvalidNetworkOrAccount(network, account);
         }
     }
     getPermittedMethods() {
-        return this.getTezosRequiredNamespace().methods;
+        return this.getTezosNamespace().methods;
     }
     getPermittedNetwork() {
-        return this.getTezosRequiredNamespace().chains.map((chain) => chain.split(':')[1]);
+        return this.getChainsFromAccounts(this.getTezosNamespace().accounts);
+    }
+    getChainsFromAccounts(accounts) {
+        return [...new Set(accounts.map((account) => account.split(':')[1]))];
     }
     formatParameters(params) {
         const formatedParams = params;

package/dist/taquito-wallet-connect.es6.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-wallet-connect.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-wallet-connect.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/taquito-wallet-connect.umd.js

@@ -182,18 +182,20 @@
           this.walletConnectModal = WalletConnectModal;
           this.signClient.on('session_delete', ({ topic }) => {
               if (this.session?.topic === topic) {
-                  this.session = undefined;
+                  this.clearState();
               }
           });
           this.signClient.on('session_expire', ({ topic }) => {
               if (this.session?.topic === topic) {
-                  this.session = undefined;
+                  this.clearState();
               }
           });
           this.signClient.on('session_update', ({ params, topic }) => {
               if (this.session?.topic === topic) {
-                  this.session.namespaces = params.namespaces;
-                  // TODO determine if we need validation on the namespace here
+                  this.activateSession({
+                      ...this.session,
+                      namespaces: params.namespaces,
+                  }, undefined, false);
               }
           });
           this.signClient.on('session_event', () => {
@@ -237,10 +239,11 @@
        */
       async requestPermissions(connectParams) {
           // TODO when Tezos wallets will officially support wallet connect, we need to provide a default value for registryUrl
+          let approvedSession;
           try {
               const chains = connectParams.permissionScope.networks.map((network) => `${TEZOS_PLACEHOLDER}:${network}`);
               const { uri, approval } = await this.signClient.connect({
-                  requiredNamespaces: {
+                  optionalNamespaces: {
                       [TEZOS_PLACEHOLDER]: {
                           chains,
                           methods: connectParams.permissionScope.methods,
@@ -255,7 +258,7 @@
                       chains,
                   });
               }
-              this.session = await approval();
+              approvedSession = await approval();
           }
           catch (error) {
               throw new ConnectionFailed(error);
@@ -263,8 +266,7 @@
           finally {
               this.walletConnectModal.closeModal();
           }
-          this.validateReceivedNamespace(connectParams.permissionScope, this.session.namespaces);
-          this.setDefaultAccountAndNetwork();
+          this.activateSession(approvedSession, connectParams.permissionScope);
       }
       /**
        * Access all existing active pairings
@@ -289,8 +291,7 @@
           if (!sessions.includes(key)) {
               throw new InvalidSessionKey(key);
           }
-          this.session = this.signClient.session.get(key);
-          this.setDefaultAccountAndNetwork();
+          this.activateSession(this.signClient.session.get(key));
       }
       async disconnect() {
           if (this.session) {
@@ -446,14 +447,28 @@
           }
           return this.activeNetwork;
       }
-      setDefaultAccountAndNetwork() {
-          const activeAccount = this.getAccounts();
-          if (activeAccount.length === 1) {
-              this.activeAccount = activeAccount[0];
+      activateSession(session, permissionScope, resetActiveState = true) {
+          this.session = session;
+          if (permissionScope) {
+              this.validateReceivedNamespace(permissionScope, session.namespaces);
           }
-          const activeNetwork = this.getNetworks();
-          if (activeNetwork.length === 1) {
-              this.activeNetwork = activeNetwork[0];
+          else {
+              this.validateRestoredNamespace(session.namespaces);
+          }
+          if (resetActiveState) {
+              this.activeAccount = undefined;
+              this.activeNetwork = undefined;
+          }
+          this.reconcileActiveAccountAndNetwork();
+      }
+      reconcileActiveAccountAndNetwork() {
+          const accounts = this.getAccounts();
+          if (!this.activeAccount || !accounts.includes(this.activeAccount)) {
+              this.activeAccount = accounts.length === 1 ? accounts[0] : undefined;
+          }
+          const networks = this.getNetworks();
+          if (!this.activeNetwork || !networks.includes(this.activeNetwork)) {
+              this.activeNetwork = networks.length === 1 ? networks[0] : undefined;
           }
       }
       clearState() {
@@ -500,6 +515,14 @@
               throw new InvalidReceivedSessionNamespace('All methods must be approved', utils.getSdkError('USER_REJECTED_METHODS').code, 'incomplete', missingMethods);
           }
       }
+      validateRestoredNamespace(receivedNamespaces) {
+          const tezosNamespace = receivedNamespaces[TEZOS_PLACEHOLDER];
+          if (!tezosNamespace) {
+              this.clearState();
+              throw new InvalidSession('Tezos not found in namespaces');
+          }
+          this.validateAccounts(this.getChainsFromAccounts(tezosNamespace.accounts), tezosNamespace.accounts);
+      }
       validateEvents(requiredEvents, receivedEvents) {
           const missingEvents = [];
           requiredEvents.forEach((method) => {
@@ -517,7 +540,6 @@
               this.clearState();
               throw new InvalidReceivedSessionNamespace('Accounts must not be empty', utils.getSdkError('USER_REJECTED_CHAINS').code, 'incomplete');
           }
-          const receivedChains = [];
           const invalidChains = [];
           const missingChains = [];
           const invalidChainsNamespace = [];
@@ -529,10 +551,6 @@
               if (accountId[0] !== TEZOS_PLACEHOLDER) {
                   invalidChainsNamespace.push(chain);
               }
-              const network = accountId[1];
-              if (!receivedChains.includes(network)) {
-                  receivedChains.push(network);
-              }
           });
           if (invalidChains.length > 0) {
               this.clearState();
@@ -542,6 +560,7 @@
               this.clearState();
               throw new InvalidReceivedSessionNamespace('Accounts must be defined in matching namespace', utils.getSdkError('UNSUPPORTED_ACCOUNTS').code, 'invalid', invalidChainsNamespace);
           }
+          const receivedChains = this.getChainsFromAccounts(receivedAccounts);
           requiredNetwork.forEach((network) => {
               if (!receivedChains.includes(network)) {
                   missingChains.push(network);
@@ -560,24 +579,19 @@
               throw new InvalidSession('Tezos not found in namespaces');
           }
       }
-      getTezosRequiredNamespace() {
-          if (TEZOS_PLACEHOLDER in this.getSession().requiredNamespaces) {
-              return this.getSession().requiredNamespaces[TEZOS_PLACEHOLDER];
-          }
-          else {
-              throw new InvalidSession('Tezos not found in requiredNamespaces');
-          }
-      }
       validateNetworkAndAccount(network, account) {
           if (!this.getTezosNamespace().accounts.includes(`${TEZOS_PLACEHOLDER}:${network}:${account}`)) {
               throw new InvalidNetworkOrAccount(network, account);
           }
       }
       getPermittedMethods() {
-          return this.getTezosRequiredNamespace().methods;
+          return this.getTezosNamespace().methods;
       }
       getPermittedNetwork() {
-          return this.getTezosRequiredNamespace().chains.map((chain) => chain.split(':')[1]);
+          return this.getChainsFromAccounts(this.getTezosNamespace().accounts);
+      }
+      getChainsFromAccounts(accounts) {
+          return [...new Set(accounts.map((account) => account.split(':')[1]))];
       }
       formatParameters(params) {
           const formatedParams = params;

package/dist/taquito-wallet-connect.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-wallet-connect.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-wallet-connect.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/taquito/src/batch/constants.d.ts

@@ -0,0 +1,3 @@
+import { OpKind } from '@taquito/rpc';
+export declare const BATCH_KINDS: OpKind[];
+export type BatchKinds = OpKind.ACTIVATION | OpKind.ORIGINATION | OpKind.TRANSACTION | OpKind.DELEGATION | OpKind.REGISTER_GLOBAL_CONSTANT | OpKind.INCREASE_PAID_STORAGE | OpKind.TRANSFER_TICKET | OpKind.SMART_ROLLUP_ADD_MESSAGES | OpKind.SMART_ROLLUP_ORIGINATE | OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE;

package/dist/types/taquito/src/batch/rpc-batch-provider.d.ts

@@ -0,0 +1,139 @@
+import { Context } from '../context';
+import { ContractStorageType, DefaultContractType } from '../contract/contract';
+import { SendParams } from '../contract/contract-methods/contract-method-interface';
+import { ContractProvider } from '../contract/interface';
+import { BatchOperation } from '../operations/batch-operation';
+import { ActivationParams, DelegateParams, OriginateParams, TransferParams, ParamsWithKind, RegisterGlobalConstantParams, TransferTicketParams, IncreasePaidStorageParams, SmartRollupAddMessagesParams, SmartRollupOriginateParams, SmartRollupExecuteOutboxMessageParams, UpdateConsensusKeyParams, UpdateCompanionKeyParams } from '../operations/types';
+import { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
+import { EstimationProvider } from '../estimate/estimate-provider-interface';
+import { Provider } from '../provider';
+export { BATCH_KINDS, BatchKinds } from './constants';
+export declare class OperationBatch extends Provider {
+    private estimator;
+    private operations;
+    constructor(context: Context, estimator: EstimationProvider);
+    private prepare;
+    /**
+     *
+     * Add a transaction operation to the batch
+     *
+     * @param params Transfer operation parameter
+     */
+    withTransfer(params: TransferParams): this;
+    /**
+     *
+     * Transfer tickets from a Tezos address (tz1,tz2 or tz3) to a smart contract address( KT1)
+     *
+     * @param params Transfer operation parameter
+     */
+    withTransferTicket(params: TransferTicketParams): this;
+    /**
+     *
+     * Add a contract call to the batch
+     *
+     * @param params Call a contract method
+     * @param options Generic operation parameters
+     */
+    withContractCall(params: ContractMethodObject<ContractProvider>, options?: Partial<SendParams>): this;
+    /**
+     *
+     * Add a delegation operation to the batch
+     *
+     * @param params Delegation operation parameter
+     */
+    withDelegation(params: DelegateParams): this;
+    /**
+     *
+     * Add an activation operation to the batch
+     *
+     * @param params Activation operation parameter
+     * @throws InvalidKeyHashError
+     */
+    withActivation({ pkh, secret }: ActivationParams): this;
+    /**
+     *
+     * Add an origination operation to the batch
+     *
+     * @param params Origination operation parameter
+     */
+    withOrigination<TContract extends DefaultContractType = DefaultContractType>(params: OriginateParams<ContractStorageType<TContract>>): this;
+    /**
+     *
+     * Add a register a global constant operation to the batch
+     *
+     * @param params RegisterGlobalConstant operation parameter
+     */
+    withRegisterGlobalConstant(params: RegisterGlobalConstantParams): this;
+    /**
+     *
+     * Add an increase paid storage operation to the batch
+     *
+     * @param params IncreasePaidStorage operation parameter
+     */
+    withIncreasePaidStorage(params: IncreasePaidStorageParams): this;
+    /**
+     *
+     * Add a update consensus key operation to the batch
+     *
+     * @param params UpdateConsensusKey operation parameter
+     */
+    withUpdateConsensusKey(params: UpdateConsensusKeyParams): this;
+    /**
+     *
+     * Add a update companion key operation to the batch
+     *
+     * @param params UpdateCompanionKey operation parameter
+     */
+    withUpdateCompanionKey(params: UpdateCompanionKeyParams): this;
+    /**
+     *
+     * Add a smart rollup add messages operation to the batch
+     *
+     * @param params Rollup origination operation parameter
+     */
+    withSmartRollupAddMessages(params: SmartRollupAddMessagesParams): this;
+    /**
+     *
+     * Add a smart rollup originate operation to the batch
+     *
+     * @param params Smart Rollup Originate operation parameter
+     */
+    withSmartRollupOriginate(params: SmartRollupOriginateParams): this;
+    /**
+     *
+     * Add a smart rollup execute outbox message to the batch
+     *
+     * @param params Smart Rollup Execute Outbox Message operation parameter
+     */
+    withSmartRollupExecuteOutboxMessage(params: SmartRollupExecuteOutboxMessageParams): this;
+    getRPCOp(param: ParamsWithKind): Promise<import("../operations/types").RPCTransferOperation | import("../operations/types").RPCOriginationOperation | import("../operations/types").RPCDelegateOperation | import("../operations/types").RPCRegisterGlobalConstantOperation | import("../operations/types").RPCIncreasePaidStorageOperation | import("../operations/types").RPCUpdateConsensusKeyOperation | import("../operations/types").RPCUpdateCompanionKeyOperation | import("../operations/types").RPCTransferTicketOperation | import("../operations/types").RPCSmartRollupAddMessagesOperation | import("../operations/types").RPCSmartRollupOriginateOperation | import("../operations/types").RPCSmartRollupOutboxMessageOperation>;
+    /**
+     *
+     * 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: ParamsWithKind[]): this;
+    /**
+     *
+     * Forge and Inject the operation batch
+     *
+     * @param params Optionally specify the source of the operation
+     */
+    send(params?: {
+        source?: string;
+    }): Promise<BatchOperation>;
+}
+export declare class RPCBatchProvider {
+    private context;
+    private estimator;
+    constructor(context: Context, estimator: EstimationProvider);
+    /***
+     *
+     * 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?: ParamsWithKind[]): OperationBatch;
+}

package/dist/types/taquito/src/constants.d.ts

@@ -0,0 +1,81 @@
+export declare const REVEAL_STORAGE_LIMIT = 0;
+export declare const ORIGINATION_SIZE = 257;
+export declare const COST_PER_BYTE = 250;
+export declare enum Protocols {
+    Pt24m4xi = "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd",
+    PsBABY5H = "PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU",
+    PsBabyM1 = "PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS",
+    PsCARTHA = "PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb",
+    PsDELPH1 = "PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo",
+    PtEdo2Zk = "PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA",
+    PsFLorena = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i",
+    PtGRANADs = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV",
+    PtHangz2 = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx",
+    PsiThaCa = "PsiThaCaT47Zboaw71QWScM8sXeMM7bbQFncK9FLqYc6EKdpjVP",
+    Psithaca2 = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A",
+    PtJakart2 = "PtJakart2xVj7pYXJBXrqHgd82rdkLey5ZeeGwDgPp9rhQUbSqY",
+    PtKathman = "PtKathmankSpLLDALzWw7CGD2j2MtyveTwboEYokqUCP4a1LxMg",
+    PtLimaPtL = "PtLimaPtLMwfNinJi9rCfDPWea8dFgTZ1MeJ9f1m2SRic6ayiwW",
+    PtMumbaii = "PtMumbaiiFFEGbew1rRjzSPyzRbA51Tm3RVZL5suHPxSZYDhCEc",
+    PtMumbai2 = "PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1",
+    PtNairobi = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf",
+    ProxfordY = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH",
+    PtParisBx = "PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ",
+    PsParisCZ = "PsParisCZo7KAh1Z1smVd9ZMZ1HHn5gkzbM94V3PLCpknFWhUAi",
+    PsQuebecn = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg",
+    PsRiotuma = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7",
+    PtSeouLou = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh",
+    PtTALLiNt = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu",
+    ProtoALpha = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK"
+}
+export declare const protocols: {
+    '004': Protocols[];
+    '005': Protocols[];
+    '006': Protocols[];
+    '007': Protocols[];
+    '008': Protocols[];
+    '009': Protocols[];
+    '010': Protocols[];
+    '011': Protocols[];
+    '012': Protocols[];
+    '013': Protocols[];
+    '014': Protocols[];
+    '015': Protocols[];
+    '016': Protocols[];
+    '017': Protocols[];
+    '019': Protocols[];
+    '020': Protocols[];
+    '021': Protocols[];
+    '022': Protocols[];
+    '023': Protocols[];
+    '024': Protocols[];
+    '025': Protocols[];
+};
+export declare enum ChainIds {
+    MAINNET = "NetXdQprcVkpaWU",
+    GHOSTNET = "NetXnHfVqm9iesp",
+    SHADOWNET = "NetXsqzbfFenSTS",
+    CARTHAGENET = "NetXjD3HPJJjmcd",
+    DELPHINET = "NetXm8tYqnMWky1",
+    EDONET = "NetXSgo1ZT2DRUG",
+    FLORENCENET = "NetXxkAx4woPLyu",
+    GRANADANET = "NetXz969SFaFn8k",
+    HANGZHOUNET = "NetXZSsxBpMQeAT",
+    ITHACANET = "NetXbhmtAbMukLc",
+    JAKARTANET2 = "NetXLH1uAxK7CCh",
+    KATHMANDUNET = "NetXazhm4yetmff",
+    LIMANET = "NetXizpkH94bocH",
+    MUMBAINET = "NetXQw6nWSnrJ5t",
+    MUMBAINET2 = "NetXgbcrNtXD2yA",
+    NAIROBINET = "NetXyuzvDo2Ugzb",
+    OXFORDNET2 = "NetXxWsskGahzQB",
+    PARISBNET = "NetXo8SqH1c38SS",
+    PARISCNET = "NetXXWAHLEvre9b",
+    QUEBECNET = "NetXuTeGinLEqxp",
+    RIONET = "NetXPdgaoabtBth",
+    SEOULNET = "NetXd56aBs1aeW3",
+    TALLINNNET = "NetXe8DbhW9A1eS"
+}
+export declare const getRevealGasLimit: (address: string) => number;
+export declare const getRevealFee: (address: string) => number;
+export declare const getRevealFeeInternal: (address: string) => number;