@taquito/taquito 17.5.2 → 19.0.0-beta-RC.0

package/dist/taquito.umd.js

@@ -204,6 +204,7 @@
         Protocols["PtMumbaii"] = "PtMumbaiiFFEGbew1rRjzSPyzRbA51Tm3RVZL5suHPxSZYDhCEc";
         Protocols["PtMumbai2"] = "PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1";
         Protocols["PtNairobi"] = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf";
+        Protocols["ProxfordY"] = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH";
         Protocols["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
     })(exports.Protocols || (exports.Protocols = {}));
     const protocols = {
@@ -221,7 +222,8 @@
         '015': [exports.Protocols.PtLimaPtL],
         '016': [exports.Protocols.PtMumbai2],
         '017': [exports.Protocols.PtNairobi],
-        '018': [exports.Protocols.ProtoALpha],
+        '019': [exports.Protocols.ProxfordY],
+        '020': [exports.Protocols.ProtoALpha],
     };
     exports.ChainIds = void 0;
     (function (ChainIds) {
@@ -240,6 +242,7 @@
         ChainIds["MUMBAINET"] = "NetXQw6nWSnrJ5t";
         ChainIds["MUMBAINET2"] = "NetXgbcrNtXD2yA";
         ChainIds["NAIROBINET"] = "NetXyuzvDo2Ugzb";
+        ChainIds["OXFORDNET2"] = "NetXxWsskGahzQB";
     })(exports.ChainIds || (exports.ChainIds = {}));
     const getRevealGasLimit = (address) => Math.round((getRevealGasLimitInternal(address) * 11) / 10);
     const getRevealGasLimitInternal = (address) => {
@@ -554,7 +557,7 @@
             message,
         };
     });
-    const createSmartRollupOriginateOperation = ({ source, fee, gasLimit, storageLimit, pvmKind, kernel, originationProof, parametersType, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const createSmartRollupOriginateOperation = ({ source, fee, gasLimit, storageLimit, pvmKind, kernel, parametersType, }) => __awaiter(void 0, void 0, void 0, function* () {
         return {
             kind: rpc.OpKind.SMART_ROLLUP_ORIGINATE,
             source,
@@ -563,7 +566,6 @@
             storage_limit: storageLimit,
             pvm_kind: pvmKind,
             kernel,
-            origination_proof: originationProof,
             parameters_ty: parametersType,
         };
     });
@@ -590,8 +592,6 @@
             'reveal',
             'register_global_constant',
             'increase_paid_storage',
-            'tx_rollup_origination',
-            'tx_rollup_submit_batch',
             'transfer_ticket',
             'update_consensus_key',
             'smart_rollup_add_messages',
@@ -605,8 +605,6 @@
             'origination',
             'register_global_constant',
             'increase_paid_storage',
-            'tx_rollup_origination',
-            'tx_rollup_submit_batch',
             'transfer_ticket',
             'update_consensus_key',
             'smart_rollup_add_messages',
@@ -3053,13 +3051,9 @@
             var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
             return __awaiter(this, void 0, void 0, function* () {
                 const { pkh } = yield this.getKeys();
-                const originationProof = yield this.rpc.getOriginationProof({
-                    kind: rest.pvmKind,
-                    kernel: rest.kernel,
-                });
                 const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
                 const DEFAULT_PARAMS = yield this.getAccountLimits(pkh, protocolConstants);
-                const op = yield createSmartRollupOriginateOperation(Object.assign(Object.assign(Object.assign({}, mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS)), rest), { originationProof }));
+                const op = yield createSmartRollupOriginateOperation(Object.assign(Object.assign({}, mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS)), rest));
                 const operation = yield this.addRevealOperationIfNeeded(op, pkh);
                 const ops = this.convertIntoArray(operation);
                 const hash = yield this.getBlockHash();
@@ -4808,9 +4802,6 @@
         get kernel() {
             return this.params.kernel;
         }
-        get originationProof() {
-            return this.params.origination_proof;
-        }
         get errors() {
             var _a;
             return (_a = this.operationResults) === null || _a === void 0 ? void 0 : _a.errors;
@@ -5288,12 +5279,7 @@
             return __awaiter(this, void 0, void 0, function* () {
                 const publicKeyHash = yield this.signer.publicKeyHash();
                 const estimate = yield this.estimate(params, this.estimator.smartRollupOriginate.bind(this.estimator));
-                const originationProof = yield this.rpc.getOriginationProof({
-                    kind: params.pvmKind,
-                    kernel: params.kernel,
-                });
-                const completeParams = Object.assign(Object.assign({}, params), { originationProof });
-                const prepared = yield this.prepare.smartRollupOriginate(Object.assign(Object.assign({}, completeParams), estimate));
+                const prepared = yield this.prepare.smartRollupOriginate(Object.assign(Object.assign({}, params), estimate));
                 const content = prepared.opOb.contents.find((op) => op.kind === rpc.OpKind.SMART_ROLLUP_ORIGINATE);
                 const opBytes = yield this.forge(prepared);
                 const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
@@ -5582,7 +5568,7 @@
          */
         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, tx_rollup_origination_size, smart_rollup_origination_size, } = yield this.rpc.getConstants({ block: String(block) });
+                const { time_between_blocks, minimal_block_delay, hard_gas_limit_per_operation, hard_gas_limit_per_block, hard_storage_limit_per_operation, cost_per_byte, smart_rollup_origination_size, } = yield this.rpc.getConstants({ block: String(block) });
                 return {
                     time_between_blocks,
                     minimal_block_delay,
@@ -5590,7 +5576,6 @@
                     hard_gas_limit_per_block,
                     hard_storage_limit_per_operation,
                     cost_per_byte,
-                    tx_rollup_origination_size,
                     smart_rollup_origination_size,
                 };
             });
@@ -5764,6 +5749,8 @@
     const opHashFilter = (op, filter) => op.hash === filter.opHash;
     const sourceFilter = (x, filter) => {
         switch (x.kind) {
+            case 'attestation':
+                return 'metadata' in x && x.metadata.delegate === filter.source;
             case 'endorsement':
                 return 'metadata' in x && x.metadata.delegate === filter.source;
             case 'activate_account':
@@ -6196,8 +6183,8 @@
 
     // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
     const VERSION = {
-        "commitHash": "46a535eea78d77ebb5509ccd1d1cbd01075c7461",
-        "version": "17.5.2"
+        "commitHash": "bd52c12d05e329e4cf3a81fe55c4778a47879ccd",
+        "version": "19.0.0-beta-RC.0"
     };
 
     /**

package/dist/taquito.umd.js.map

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

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

@@ -4,7 +4,7 @@ import { ContractMethod } from '../contract/contract-methods/contract-method-fla
 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, SmartRollupOriginateParamsWithProof } from '../operations/types';
+import { ActivationParams, DelegateParams, OriginateParams, TransferParams, ParamsWithKind, RegisterGlobalConstantParams, TransferTicketParams, IncreasePaidStorageParams, SmartRollupAddMessagesParams, SmartRollupOriginateParams } from '../operations/types';
 import { OpKind } from '@taquito/rpc';
 import { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
 import { EstimationProvider } from '../estimate/estimate-provider-interface';
@@ -87,7 +87,7 @@ export declare class OperationBatch extends Provider {
      *
      * @param params Smart Rollup Originate operation parameter
      */
-    withSmartRollupOriginate(params: SmartRollupOriginateParamsWithProof): this;
+    withSmartRollupOriginate(params: SmartRollupOriginateParams): 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").RPCTransferTicketOperation | import("../operations/types").RPCSmartRollupAddMessagesOperation | import("../operations/types").RPCSmartRollupOriginateOperation>;
     /**
      *

package/dist/types/constants.d.ts

@@ -38,6 +38,7 @@ export declare enum Protocols {
     PtMumbaii = "PtMumbaiiFFEGbew1rRjzSPyzRbA51Tm3RVZL5suHPxSZYDhCEc",
     PtMumbai2 = "PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1",
     PtNairobi = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf",
+    ProxfordY = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH",
     ProtoALpha = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK"
 }
 export declare const protocols: {
@@ -55,7 +56,8 @@ export declare const protocols: {
     '015': Protocols[];
     '016': Protocols[];
     '017': Protocols[];
-    '018': Protocols[];
+    '019': Protocols[];
+    '020': Protocols[];
 };
 export declare enum ChainIds {
     MAINNET = "NetXdQprcVkpaWU",
@@ -72,6 +74,7 @@ export declare enum ChainIds {
     LIMANET = "NetXizpkH94bocH",
     MUMBAINET = "NetXQw6nWSnrJ5t",
     MUMBAINET2 = "NetXgbcrNtXD2yA",
-    NAIROBINET = "NetXyuzvDo2Ugzb"
+    NAIROBINET = "NetXyuzvDo2Ugzb",
+    OXFORDNET2 = "NetXxWsskGahzQB"
 }
 export declare const getRevealGasLimit: (address: string) => number;

package/dist/types/contract/prepare.d.ts

@@ -1,4 +1,4 @@
-import { OriginateParams, RPCOriginationOperation, TransferParams, RPCTransferOperation, DelegateParams, RPCDelegateOperation, RegisterDelegateParams, RPCRevealOperation, RevealParams, RegisterGlobalConstantParams, RPCRegisterGlobalConstantOperation, TransferTicketParams, RPCTransferTicketOperation, IncreasePaidStorageParams, RPCIncreasePaidStorageOperation, DrainDelegateParams, RPCDrainDelegateOperation, BallotParams, RPCBallotOperation, ProposalsParams, RPCProposalsOperation, UpdateConsensusKeyParams, RPCUpdateConsensusKeyOperation, SmartRollupAddMessagesParams, RPCSmartRollupAddMessagesOperation, RPCSmartRollupOriginateOperation, SmartRollupOriginateParamsWithProof, ActivationParams, RPCActivateOperation } from '../operations/types';
+import { OriginateParams, RPCOriginationOperation, TransferParams, RPCTransferOperation, DelegateParams, RPCDelegateOperation, RegisterDelegateParams, RPCRevealOperation, RevealParams, RegisterGlobalConstantParams, RPCRegisterGlobalConstantOperation, TransferTicketParams, RPCTransferTicketOperation, IncreasePaidStorageParams, RPCIncreasePaidStorageOperation, DrainDelegateParams, RPCDrainDelegateOperation, BallotParams, RPCBallotOperation, ProposalsParams, RPCProposalsOperation, UpdateConsensusKeyParams, RPCUpdateConsensusKeyOperation, SmartRollupAddMessagesParams, RPCSmartRollupAddMessagesOperation, RPCSmartRollupOriginateOperation, ActivationParams, RPCActivateOperation, SmartRollupOriginateParams } from '../operations/types';
 export declare const createActivationOperation: ({ pkh, secret }: ActivationParams) => Promise<RPCActivateOperation>;
 export declare const createOriginationOperation: ({ code, init, balance, delegate, storage, fee, gasLimit, storageLimit, mutez, }: OriginateParams) => Promise<RPCOriginationOperation>;
 export declare const createTransferOperation: ({ to, amount, parameter, fee, gasLimit, storageLimit, mutez, }: TransferParams) => Promise<RPCTransferOperation>;
@@ -13,4 +13,4 @@ export declare const createBallotOperation: ({ source, proposal, ballot }: Ballo
 export declare const createProposalsOperation: ({ source, proposals }: ProposalsParams) => Promise<RPCProposalsOperation>;
 export declare const createUpdateConsensusKeyOperation: ({ source, fee, gasLimit, storageLimit, pk, }: UpdateConsensusKeyParams) => Promise<RPCUpdateConsensusKeyOperation>;
 export declare const createSmartRollupAddMessagesOperation: ({ source, fee, gasLimit, storageLimit, message, }: SmartRollupAddMessagesParams) => Promise<RPCSmartRollupAddMessagesOperation>;
-export declare const createSmartRollupOriginateOperation: ({ source, fee, gasLimit, storageLimit, pvmKind, kernel, originationProof, parametersType, }: SmartRollupOriginateParamsWithProof) => Promise<RPCSmartRollupOriginateOperation>;
+export declare const createSmartRollupOriginateOperation: ({ source, fee, gasLimit, storageLimit, pvmKind, kernel, parametersType, }: SmartRollupOriginateParams) => Promise<RPCSmartRollupOriginateOperation>;

package/dist/types/operations/errors.d.ts

@@ -1,5 +1,5 @@
 import { ParameterValidationError, RpcError, TaquitoError } from '@taquito/core';
-import { MichelsonV1ExpressionBase, OperationResultDelegation, OperationResultOrigination, OperationResultRegisterGlobalConstant, OperationResultReveal, OperationResultSmartRollupOriginate, OperationResultTransaction, OperationResultTransferTicket, OperationResultTxRollupOrigination, OperationResultTxRollupSubmitBatch, PreapplyResponse, TezosGenericOperationError } from '@taquito/rpc';
+import { MichelsonV1ExpressionBase, OperationResultDelegation, OperationResultOrigination, OperationResultRegisterGlobalConstant, OperationResultReveal, OperationResultSmartRollupOriginate, OperationResultTransaction, OperationResultTransferTicket, PreapplyResponse, TezosGenericOperationError } from '@taquito/rpc';
 export interface TezosOperationErrorWithMessage extends TezosGenericOperationError {
     with: MichelsonV1ExpressionBase;
 }
@@ -22,7 +22,7 @@ export declare class TezosPreapplyFailureError extends Error {
     readonly result: any;
     constructor(result: any);
 }
-export type MergedOperationResult = OperationResultTransaction & OperationResultOrigination & OperationResultDelegation & OperationResultRegisterGlobalConstant & OperationResultTxRollupOrigination & OperationResultTxRollupSubmitBatch & OperationResultTransferTicket & Partial<OperationResultSmartRollupOriginate> & OperationResultReveal & {
+export type MergedOperationResult = OperationResultTransaction & OperationResultOrigination & OperationResultDelegation & OperationResultRegisterGlobalConstant & OperationResultTransferTicket & Partial<OperationResultSmartRollupOriginate> & OperationResultReveal & {
     fee?: string;
 };
 export declare const flattenOperationResult: (response: PreapplyResponse | PreapplyResponse[]) => MergedOperationResult[];

package/dist/types/operations/smart-rollup-originate-operation.d.ts

@@ -19,6 +19,5 @@ export declare class SmartRollupOriginateOperation extends Operation implements
     get consumedMilliGas(): string | undefined;
     get pvmKind(): import("@taquito/rpc").PvmKind;
     get kernel(): string;
-    get originationProof(): string;
     get errors(): import("@taquito/rpc").TezosGenericOperationError[] | undefined;
 }

package/dist/types/operations/types.d.ts

@@ -4,7 +4,7 @@ export { OpKind } from '@taquito/rpc';
 export type withKind<T, K extends OpKind> = T & {
     kind: K;
 };
-export type ParamsWithKind = withKind<OriginateParams, OpKind.ORIGINATION> | withKind<DelegateParams, OpKind.DELEGATION> | withKind<TransferParams, OpKind.TRANSACTION> | withKind<ActivationParams, OpKind.ACTIVATION> | withKind<RegisterGlobalConstantParams, OpKind.REGISTER_GLOBAL_CONSTANT> | withKind<IncreasePaidStorageParams, OpKind.INCREASE_PAID_STORAGE> | withKind<TxRollupOriginateParams, OpKind.TX_ROLLUP_ORIGINATION> | withKind<TxRollupBatchParams, OpKind.TX_ROLLUP_SUBMIT_BATCH> | withKind<TransferTicketParams, OpKind.TRANSFER_TICKET> | withKind<UpdateConsensusKeyParams, OpKind.UPDATE_CONSENSUS_KEY> | withKind<SmartRollupAddMessagesParams, OpKind.SMART_ROLLUP_ADD_MESSAGES> | withKind<FailingNoopParams, OpKind.FAILING_NOOP> | withKind<SmartRollupOriginateParamsWithProof, OpKind.SMART_ROLLUP_ORIGINATE>;
+export type ParamsWithKind = withKind<OriginateParams, OpKind.ORIGINATION> | withKind<DelegateParams, OpKind.DELEGATION> | withKind<TransferParams, OpKind.TRANSACTION> | withKind<ActivationParams, OpKind.ACTIVATION> | withKind<RegisterGlobalConstantParams, OpKind.REGISTER_GLOBAL_CONSTANT> | withKind<IncreasePaidStorageParams, OpKind.INCREASE_PAID_STORAGE> | withKind<TransferTicketParams, OpKind.TRANSFER_TICKET> | withKind<UpdateConsensusKeyParams, OpKind.UPDATE_CONSENSUS_KEY> | withKind<SmartRollupAddMessagesParams, OpKind.SMART_ROLLUP_ADD_MESSAGES> | withKind<FailingNoopParams, OpKind.FAILING_NOOP> | withKind<SmartRollupOriginateParams, OpKind.SMART_ROLLUP_ORIGINATE>;
 export type ParamsWithKindExtended = ParamsWithKind | withKind<RevealParams, OpKind.REVEAL>;
 export declare const attachKind: <T, K extends OpKind>(op: T, kind: K) => withKind<T, K>;
 export declare const findWithKind: <T extends {
@@ -15,11 +15,11 @@ export declare const findWithKind: <T extends {
 export declare const isKind: <T extends {
     kind: OpKind;
 }, K extends OpKind>(op: T, kind: K) => op is withKind<T, K>;
-export type RPCOpWithFee = RPCTransferOperation | RPCOriginationOperation | RPCDelegateOperation | RPCRevealOperation | RPCRegisterGlobalConstantOperation | RPCIncreasePaidStorageOperation | RPCTxRollupOriginationOperation | RPCTxRollupBatchOperation | RPCTransferTicketOperation | RPCUpdateConsensusKeyOperation | RPCSmartRollupAddMessagesOperation | RPCSmartRollupOriginateOperation;
-export type RPCOpWithSource = RPCTransferOperation | RPCOriginationOperation | RPCDelegateOperation | RPCRevealOperation | RPCRegisterGlobalConstantOperation | RPCIncreasePaidStorageOperation | RPCTxRollupOriginationOperation | RPCTxRollupBatchOperation | RPCTransferTicketOperation | RPCUpdateConsensusKeyOperation | RPCSmartRollupAddMessagesOperation | RPCSmartRollupOriginateOperation;
+export type RPCOpWithFee = RPCTransferOperation | RPCOriginationOperation | RPCDelegateOperation | RPCRevealOperation | RPCRegisterGlobalConstantOperation | RPCIncreasePaidStorageOperation | RPCTransferTicketOperation | RPCUpdateConsensusKeyOperation | RPCSmartRollupAddMessagesOperation | RPCSmartRollupOriginateOperation;
+export type RPCOpWithSource = RPCTransferOperation | RPCOriginationOperation | RPCDelegateOperation | RPCRevealOperation | RPCRegisterGlobalConstantOperation | RPCIncreasePaidStorageOperation | RPCTransferTicketOperation | RPCUpdateConsensusKeyOperation | RPCSmartRollupAddMessagesOperation | RPCSmartRollupOriginateOperation;
 export declare const isOpWithFee: <T extends {
     kind: OpKind;
-}>(op: T) => op is withKind<T, OpKind.ORIGINATION | OpKind.DELEGATION | OpKind.REVEAL | OpKind.TRANSACTION | OpKind.ENDORSEMENT | OpKind.PREENDORSEMENT | OpKind.SET_DEPOSITS_LIMIT | OpKind.DOUBLE_PREENDORSEMENT_EVIDENCE | OpKind.ENDORSEMENT_WITH_SLOT | OpKind.SEED_NONCE_REVELATION | OpKind.DOUBLE_ENDORSEMENT_EVIDENCE | OpKind.DOUBLE_BAKING_EVIDENCE | OpKind.PROPOSALS | OpKind.BALLOT | OpKind.REGISTER_GLOBAL_CONSTANT | OpKind.TX_ROLLUP_ORIGINATION | OpKind.TX_ROLLUP_SUBMIT_BATCH | OpKind.TX_ROLLUP_COMMIT | OpKind.TX_ROLLUP_RETURN_BOND | OpKind.TX_ROLLUP_FINALIZE_COMMITMENT | OpKind.TX_ROLLUP_REMOVE_COMMITMENT | OpKind.TX_ROLLUP_REJECTION | OpKind.TX_ROLLUP_DISPATCH_TICKETS | OpKind.TRANSFER_TICKET | OpKind.INCREASE_PAID_STORAGE | OpKind.UPDATE_CONSENSUS_KEY | OpKind.DRAIN_DELEGATE | OpKind.VDF_REVELATION | OpKind.EVENT | OpKind.TICKET_UPDATES | OpKind.SMART_ROLLUP_ORIGINATE | OpKind.SMART_ROLLUP_ADD_MESSAGES | OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE | OpKind.SMART_ROLLUP_PUBLISH | OpKind.SMART_ROLLUP_CEMENT | OpKind.SMART_ROLLUP_RECOVER_BOND | OpKind.SMART_ROLLUP_REFUTE | OpKind.SMART_ROLLUP_TIMEOUT>;
+}>(op: T) => op is withKind<T, OpKind.ORIGINATION | OpKind.DELEGATION | OpKind.REVEAL | OpKind.TRANSACTION | OpKind.ATTESTATION | OpKind.ENDORSEMENT | OpKind.PREATTESTATION | OpKind.PREENDORSEMENT | OpKind.SET_DEPOSITS_LIMIT | OpKind.DOUBLE_PREATTESTATION_EVIDENCE | OpKind.DOUBLE_PREENDORSEMENT_EVIDENCE | OpKind.ATTESTATION_WITH_SLOT | OpKind.ENDORSEMENT_WITH_SLOT | OpKind.SEED_NONCE_REVELATION | OpKind.DOUBLE_ATTESTATION_EVIDENCE | OpKind.DOUBLE_ENDORSEMENT_EVIDENCE | OpKind.DOUBLE_BAKING_EVIDENCE | OpKind.PROPOSALS | OpKind.BALLOT | OpKind.REGISTER_GLOBAL_CONSTANT | OpKind.TRANSFER_TICKET | OpKind.INCREASE_PAID_STORAGE | OpKind.UPDATE_CONSENSUS_KEY | OpKind.DRAIN_DELEGATE | OpKind.VDF_REVELATION | OpKind.EVENT | OpKind.TICKET_UPDATES | OpKind.SMART_ROLLUP_ORIGINATE | OpKind.SMART_ROLLUP_ADD_MESSAGES | OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE | OpKind.SMART_ROLLUP_PUBLISH | OpKind.SMART_ROLLUP_CEMENT | OpKind.SMART_ROLLUP_RECOVER_BOND | OpKind.SMART_ROLLUP_REFUTE | OpKind.SMART_ROLLUP_TIMEOUT>;
 export declare const isOpRequireReveal: <T extends {
     kind: OpKind;
 }>(op: T) => op is withKind<T, OpKind.ORIGINATION | OpKind.DELEGATION | OpKind.TRANSACTION | OpKind.EVENT>;
@@ -207,49 +207,6 @@ export interface RPCActivateOperation {
     pkh: string;
     secret: string;
 }
-/**
- * @description RPC tx rollup origination operation
- */
-export interface RPCTxRollupOriginationOperation {
-    kind: OpKind.TX_ROLLUP_ORIGINATION;
-    fee: number;
-    gas_limit: number;
-    storage_limit: number;
-    source: string;
-    tx_rollup_origination: object;
-}
-/**
- * @description Parameters for the `txRollupOriginate` method
- */
-export interface TxRollupOriginateParams {
-    source?: string;
-    fee?: number;
-    gasLimit?: number;
-    storageLimit?: number;
-}
-/**
- * @description Parameters for the `txRollupSubmitBatch` method
- */
-export interface TxRollupBatchParams {
-    source?: string;
-    fee?: number;
-    gasLimit?: number;
-    storageLimit?: number;
-    rollup: string;
-    content: string;
-}
-/**
- * @description RPC tx rollup batch operation
- */
-export interface RPCTxRollupBatchOperation {
-    kind: OpKind.TX_ROLLUP_SUBMIT_BATCH;
-    fee: number;
-    gas_limit: number;
-    storage_limit: number;
-    source: string;
-    rollup: string;
-    content: string;
-}
 /**
  * @description Parameters for the transferTicket contract provider
  */
@@ -385,9 +342,6 @@ export interface SmartRollupOriginateParams {
     kernel: string;
     parametersType: MichelsonV1Expression;
 }
-export interface SmartRollupOriginateParamsWithProof extends SmartRollupOriginateParams {
-    originationProof: string;
-}
 export interface RPCSmartRollupOriginateOperation {
     kind: OpKind.SMART_ROLLUP_ORIGINATE;
     source: string;
@@ -396,7 +350,6 @@ export interface RPCSmartRollupOriginateOperation {
     storage_limit: number;
     pvm_kind: PvmKind;
     kernel: string;
-    origination_proof: string;
     parameters_ty: MichelsonV1Expression;
 }
 /**

package/dist/types/read-provider/interface.d.ts

@@ -39,7 +39,6 @@ export interface TzReadProvider {
         hard_gas_limit_per_block: BigNumber;
         hard_storage_limit_per_operation: BigNumber;
         cost_per_byte: BigNumber;
-        tx_rollup_origination_size?: number;
         smart_rollup_origination_size: number;
     }>;
     /**

package/dist/types/read-provider/rpc-read-adapter.d.ts

@@ -37,7 +37,6 @@ export declare class RpcReadAdapter implements TzReadProvider {
         hard_gas_limit_per_block: BigNumber;
         hard_storage_limit_per_operation: BigNumber;
         cost_per_byte: BigNumber;
-        tx_rollup_origination_size?: number;
         smart_rollup_origination_size: number;
     }>;
     /**

package/dist/types/signer/interface.d.ts

@@ -5,7 +5,7 @@ export interface Signer {
     /**
      *
      * @param op Operation to sign
-     * @param magicByte Magic bytes 11 for block, 12 for preendorsement, 13 for endorsements, 3 for generic, 5 for the PACK format of michelson
+     * @param magicByte Magic bytes 11 for block, 12 for preattestation/preendorsement, 13 for attestation/endorsements, 3 for generic, 5 for the PACK format of michelson
      */
     sign(op: string, magicByte?: Uint8Array): Promise<{
         bytes: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/taquito",
-  "version": "17.5.2",
+  "version": "19.0.0-beta-RC.0",
   "description": "High level functionality that builds upon the other packages in the Tezos Typescript Library Suite.",
   "keywords": [
     "tezos",
@@ -77,13 +77,13 @@
     ]
   },
   "dependencies": {
-    "@taquito/core": "^17.5.2",
-    "@taquito/http-utils": "^17.5.2",
-    "@taquito/local-forging": "^17.5.2",
-    "@taquito/michel-codec": "^17.5.2",
-    "@taquito/michelson-encoder": "^17.5.2",
-    "@taquito/rpc": "^17.5.2",
-    "@taquito/utils": "^17.5.2",
+    "@taquito/core": "^19.0.0-beta-RC.0",
+    "@taquito/http-utils": "^19.0.0-beta-RC.0",
+    "@taquito/local-forging": "^19.0.0-beta-RC.0",
+    "@taquito/michel-codec": "^19.0.0-beta-RC.0",
+    "@taquito/michelson-encoder": "^19.0.0-beta-RC.0",
+    "@taquito/rpc": "^19.0.0-beta-RC.0",
+    "@taquito/utils": "^19.0.0-beta-RC.0",
     "bignumber.js": "^9.1.2",
     "rxjs": "^7.8.1"
   },
@@ -125,5 +125,5 @@
     "webpack-cli": "^5.1.4",
     "webpack-subresource-integrity": "^5.1.0"
   },
-  "gitHead": "16d75a1beefb47874b696ee49d61769d6cf04f7b"
+  "gitHead": "959e385ba06d8932866503bb538252a3912acbc9"
 }

package/dist/lib/operations/tx-rollup-batch-operation.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TxRollupBatchOperation = void 0;
-const bignumber_js_1 = require("bignumber.js");
-const operations_1 = require("./operations");
-/**
- * @description TxRollupBatchOperation provides utility functions to fetch a newly issued operation of kind tx_rollup_submit_batch
- */
-class TxRollupBatchOperation extends operations_1.Operation {
-    constructor(hash, params, source, raw, results, context) {
-        super(hash, raw, results, context);
-        this.params = params;
-        this.source = source;
-    }
-    get operationResults() {
-        const txrollupBatchOp = Array.isArray(this.results) &&
-            this.results.find((op) => op.kind === 'tx_rollup_submit_batch');
-        const result = txrollupBatchOp && txrollupBatchOp.metadata && txrollupBatchOp.metadata.operation_result;
-        return result ? result : undefined;
-    }
-    get status() {
-        var _a, _b;
-        return (_b = (_a = this.operationResults) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 'unknown';
-    }
-    get content() {
-        return this.params.content;
-    }
-    get fee() {
-        return this.params.fee;
-    }
-    get gasLimit() {
-        return this.params.gas_limit;
-    }
-    get storageLimit() {
-        return this.params.storage_limit;
-    }
-    get errors() {
-        var _a;
-        return (_a = this.operationResults) === null || _a === void 0 ? void 0 : _a.errors;
-    }
-    get consumedGas() {
-        bignumber_js_1.BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: bignumber_js_1.BigNumber.ROUND_UP });
-        return this.consumedMilliGas
-            ? new bignumber_js_1.BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
-            : undefined;
-    }
-    get consumedMilliGas() {
-        var _a;
-        return (_a = this.operationResults) === null || _a === void 0 ? void 0 : _a.consumed_milligas;
-    }
-}
-exports.TxRollupBatchOperation = TxRollupBatchOperation;

package/dist/lib/operations/tx-rollup-origination-operation.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TxRollupOriginationOperation = void 0;
-const bignumber_js_1 = require("bignumber.js");
-const operations_1 = require("./operations");
-/**
- * @description TxRollupOriginationOperation provides utility functions to fetch a newly issued operation of kind tx_rollup_origination
- */
-class TxRollupOriginationOperation extends operations_1.Operation {
-    constructor(hash, params, source, raw, results, context) {
-        super(hash, raw, results, context);
-        this.params = params;
-        this.source = source;
-        this.originatedRollup = this.operationResults && this.operationResults.originated_rollup;
-    }
-    get operationResults() {
-        const rollupOriginationOp = Array.isArray(this.results) &&
-            this.results.find((op) => op.kind === 'tx_rollup_origination');
-        const result = rollupOriginationOp &&
-            rollupOriginationOp.metadata &&
-            rollupOriginationOp.metadata.operation_result;
-        return result ? result : undefined;
-    }
-    get status() {
-        var _a, _b;
-        return (_b = (_a = this.operationResults) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 'unknown';
-    }
-    get fee() {
-        return this.params.fee;
-    }
-    get gasLimit() {
-        return this.params.gas_limit;
-    }
-    get storageLimit() {
-        return this.params.storage_limit;
-    }
-    get errors() {
-        var _a;
-        return (_a = this.operationResults) === null || _a === void 0 ? void 0 : _a.errors;
-    }
-    get consumedGas() {
-        bignumber_js_1.BigNumber.config({ DECIMAL_PLACES: 0, ROUNDING_MODE: bignumber_js_1.BigNumber.ROUND_UP });
-        return this.consumedMilliGas
-            ? new bignumber_js_1.BigNumber(this.consumedMilliGas).dividedBy(1000).toString()
-            : undefined;
-    }
-    get consumedMilliGas() {
-        var _a;
-        return (_a = this.operationResults) === null || _a === void 0 ? void 0 : _a.consumed_milligas;
-    }
-}
-exports.TxRollupOriginationOperation = TxRollupOriginationOperation;

package/dist/types/operations/tx-rollup-batch-operation.d.ts

@@ -1,21 +0,0 @@
-import { OperationContentsAndResult } from '@taquito/rpc';
-import { Context } from '../context';
-import { Operation } from './operations';
-import { FeeConsumingOperation, ForgedBytes, GasConsumingOperation, RPCTxRollupBatchOperation, StorageConsumingOperation } from './types';
-/**
- * @description TxRollupBatchOperation provides utility functions to fetch a newly issued operation of kind tx_rollup_submit_batch
- */
-export declare class TxRollupBatchOperation extends Operation implements GasConsumingOperation, StorageConsumingOperation, FeeConsumingOperation {
-    private readonly params;
-    readonly source: string;
-    constructor(hash: string, params: RPCTxRollupBatchOperation, source: string, raw: ForgedBytes, results: OperationContentsAndResult[], context: Context);
-    get operationResults(): import("@taquito/rpc").OperationResultTxRollupSubmitBatch | undefined;
-    get status(): import("@taquito/rpc").OperationResultStatusEnum | "unknown";
-    get content(): string;
-    get fee(): number;
-    get gasLimit(): number;
-    get storageLimit(): number;
-    get errors(): import("@taquito/rpc").TezosGenericOperationError[] | undefined;
-    get consumedGas(): string | undefined;
-    get consumedMilliGas(): string | undefined;
-}

package/dist/types/operations/tx-rollup-origination-operation.d.ts

@@ -1,24 +0,0 @@
-import { OperationContentsAndResult } from '@taquito/rpc';
-import { Context } from '../context';
-import { Operation } from './operations';
-import { FeeConsumingOperation, ForgedBytes, GasConsumingOperation, RPCTxRollupOriginationOperation, StorageConsumingOperation } from './types';
-/**
- * @description TxRollupOriginationOperation provides utility functions to fetch a newly issued operation of kind tx_rollup_origination
- */
-export declare class TxRollupOriginationOperation extends Operation implements GasConsumingOperation, StorageConsumingOperation, FeeConsumingOperation {
-    private readonly params;
-    readonly source: string;
-    /**
-     * @description Address the newly originate rollup
-     */
-    readonly originatedRollup?: string;
-    constructor(hash: string, params: RPCTxRollupOriginationOperation, source: string, raw: ForgedBytes, results: OperationContentsAndResult[], context: Context);
-    get operationResults(): import("@taquito/rpc").OperationResultTxRollupOrigination | undefined;
-    get status(): import("@taquito/rpc").OperationResultStatusEnum | "unknown";
-    get fee(): number;
-    get gasLimit(): number;
-    get storageLimit(): number;
-    get errors(): import("@taquito/rpc").TezosGenericOperationError[] | undefined;
-    get consumedGas(): string | undefined;
-    get consumedMilliGas(): string | undefined;
-}