@taquito/local-forging 20.0.0-beta.0 → 20.0.0

package/dist/lib/codec.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.burnLimitDecoder = exports.burnLimitEncoder = exports.entrypointNameDecoder = exports.entrypointNameEncoder = exports.blockPayloadHashDecoder = exports.blockPayloadHashEncoder = exports.valueParameterDecoder = exports.valueParameterEncoder = exports.parametersEncoder = exports.entrypointEncoder = exports.parametersDecoder = exports.entrypointDecoder = exports.zarithDecoder = exports.zarithEncoder = exports.smartRollupCommitmentHashDecoder = exports.smartContractAddressDecoder = exports.smartRollupAddressDecoder = exports.addressDecoder = exports.smartRollupCommitmentHashEncoder = exports.publicKeyDecoder = exports.smartContractAddressEncoder = exports.smartRollupAddressEncoder = exports.addressEncoder = exports.publicKeyEncoder = exports.publicKeyHashesEncoder = exports.publicKeyHashEncoder = exports.delegateDecoder = exports.boolDecoder = exports.int16Decoder = exports.int16Encoder = exports.int32Decoder = exports.int32Encoder = exports.delegateEncoder = exports.pvmKindDecoder = exports.pvmKindEncoder = exports.ballotDecoder = exports.ballotEncoder = exports.proposalsEncoder = exports.proposalsDecoder = exports.proposalDecoder = exports.proposalEncoder = exports.boolEncoder = exports.tz1Encoder = exports.branchEncoder = exports.publicKeyHashesDecoder = exports.publicKeyHashDecoder = exports.branchDecoder = exports.tz1Decoder = exports.prefixDecoder = exports.prefixEncoder = void 0;
-exports.smartRollupMessageDecoder = exports.smartRollupMessageEncoder = exports.paddedBytesDecoder = exports.paddedBytesEncoder = exports.depositsLimitDecoder = exports.depositsLimitEncoder = void 0;
+exports.slotHeaderDecoder = exports.slotHeaderEncoder = exports.dalCommitmentDecoder = exports.dalCommitmentEncoder = exports.smartRollupMessageDecoder = exports.smartRollupMessageEncoder = exports.paddedBytesDecoder = exports.paddedBytesEncoder = exports.depositsLimitDecoder = exports.depositsLimitEncoder = void 0;
 const utils_1 = require("@taquito/utils");
 const errors_1 = require("./errors");
 const bignumber_js_1 = require("bignumber.js");
@@ -414,7 +414,7 @@ const parametersEncoder = (val) => {
     }
     const encodedEntrypoint = (0, exports.entrypointEncoder)(val.entrypoint);
     const parameters = (0, codec_1.valueEncoder)(val.value);
-    const length = (parameters.length / 2).toString(16).padStart(8, '0');
+    const length = (0, utils_2.pad)(parameters.length / 2);
     return `ff${encodedEntrypoint}${length}${parameters}`;
 };
 exports.parametersEncoder = parametersEncoder;
@@ -484,3 +484,32 @@ const smartRollupMessageDecoder = (val) => {
     return ret.map((value) => Buffer.from(value).toString('hex'));
 };
 exports.smartRollupMessageDecoder = smartRollupMessageDecoder;
+const dalCommitmentEncoder = (val) => {
+    const prefix = val.substring(0, 2);
+    if (prefix === utils_1.Prefix.SH) {
+        return (0, exports.prefixEncoder)(utils_1.Prefix.SH)(val);
+    }
+    throw new errors_1.InvalidDalCommitmentError(val, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.SH}'`);
+};
+exports.dalCommitmentEncoder = dalCommitmentEncoder;
+const dalCommitmentDecoder = (val) => {
+    const commitment = (0, exports.prefixDecoder)(utils_1.Prefix.SH)(val);
+    if (commitment.substring(0, 2) !== utils_1.Prefix.SH) {
+        throw new errors_1.InvalidDalCommitmentError(commitment, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils_1.Prefix.SH}'`);
+    }
+    return commitment;
+};
+exports.dalCommitmentDecoder = dalCommitmentDecoder;
+const slotHeaderEncoder = (val) => {
+    return (0, utils_2.pad)(val.slot_index, 2) + (0, exports.dalCommitmentEncoder)(val.commitment) + val.commitment_proof;
+};
+exports.slotHeaderEncoder = slotHeaderEncoder;
+const slotHeaderDecoder = (val) => {
+    const preamble = val.consume(1);
+    return {
+        slot_index: Number(preamble[0].toString(10)),
+        commitment: (0, exports.dalCommitmentDecoder)(val),
+        commitment_proof: (0, utils_2.toHexString)(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
+    };
+};
+exports.slotHeaderDecoder = slotHeaderDecoder;

package/dist/lib/constants.js

@@ -44,7 +44,7 @@ var CODEC;
     CODEC["OP_BALLOT"] = "ballot";
     CODEC["OP_FAILING_NOOP"] = "failing_noop";
     CODEC["OP_ATTESTATION"] = "attestation";
-    CODEC["OP_ENDORSEMENT"] = "endorsement";
+    CODEC["OP_ATTESTATION_WITH_DAL"] = "attestation_with_dal";
     CODEC["OP_SEED_NONCE_REVELATION"] = "seed_nonce_revelation";
     CODEC["OP_REVEAL"] = "reveal";
     CODEC["OP_PROPOSALS"] = "proposals";
@@ -60,8 +60,10 @@ var CODEC;
     CODEC["PVM_KIND"] = "pvm_kind";
     CODEC["OP_SMART_ROLLUP_ADD_MESSAGES"] = "smart_rollup_add_messages";
     CODEC["OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE"] = "smart_rollup_execute_outbox_message";
+    CODEC["OP_DAL_PUBLISH_COMMITMENT"] = "dal_publish_commitment";
+    CODEC["SLOT_HEADER"] = "slot_header";
 })(CODEC || (exports.CODEC = CODEC = {}));
-// See https://tezos.gitlab.io/whitedoc/michelson.html#full-grammar
+// See https://tezos.gitlab.io/shell/p2p_api.html#alpha-michelson-v1-primitives-enumeration-unsigned-8-bit-integer
 exports.opMapping = {
     '00': 'parameter',
     '01': 'storage',
@@ -220,6 +222,7 @@ exports.opMapping = {
     '9a': 'TICKET',
     '9b': 'BYTES',
     '9c': 'NAT',
+    '9d': 'Ticket',
 };
 exports.opMappingReverse = (() => {
     const result = {};
@@ -228,7 +231,7 @@ exports.opMappingReverse = (() => {
     });
     return result;
 })();
-// See https://tezos.gitlab.io/shell/p2p_api.html?highlight=p2p
+// See https://tezos.gitlab.io/shell/p2p_api.html
 exports.kindMapping = {
     0x04: 'activate_account',
     0x6b: 'reveal',
@@ -237,6 +240,7 @@ exports.kindMapping = {
     0x6d: 'origination',
     0x06: 'ballot',
     0x15: 'attestation',
+    0x17: 'attestation_with_dal',
     0x01: 'seed_nonce_revelation',
     0x05: 'proposals',
     0x6f: 'register_global_constant',
@@ -248,6 +252,7 @@ exports.kindMapping = {
     0xc8: 'smart_rollup_originate',
     0xc9: 'smart_rollup_add_messages',
     0xce: 'smart_rollup_execute_outbox_message',
+    0xe6: 'dal_publish_commitment',
     0x11: 'failing_noop',
 };
 exports.kindMappingReverse = (() => {

package/dist/lib/decoder.js

@@ -35,6 +35,7 @@ exports.decoders = {
     [constants_1.CODEC.PVM_KIND]: codec_1.pvmKindDecoder,
     [constants_1.CODEC.PADDED_BYTES]: codec_1.paddedBytesDecoder,
     [constants_1.CODEC.SMART_ROLLUP_MESSAGE]: codec_1.smartRollupMessageDecoder,
+    [constants_1.CODEC.SLOT_HEADER]: codec_1.slotHeaderDecoder,
 };
 exports.decoders[constants_1.CODEC.OPERATION] = (0, operation_1.operationDecoder)(exports.decoders);
 exports.decoders[constants_1.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.ActivationSchema)(val);
@@ -44,7 +45,7 @@ exports.decoders[constants_1.CODEC.OP_TRANSACTION] = (val) => (0, operation_1.sc
 exports.decoders[constants_1.CODEC.OP_ORIGINATION] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.OriginationSchema)(val);
 exports.decoders[constants_1.CODEC.OP_BALLOT] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.BallotSchema)(val);
 exports.decoders[constants_1.CODEC.OP_ATTESTATION] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.AttestationSchema)(val);
-exports.decoders[constants_1.CODEC.OP_ENDORSEMENT] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.EndorsementSchema)(val);
+exports.decoders[constants_1.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.AttestationWithDalSchema)(val);
 exports.decoders[constants_1.CODEC.OP_SEED_NONCE_REVELATION] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.SeedNonceRevelationSchema)(val);
 exports.decoders[constants_1.CODEC.OP_PROPOSALS] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.ProposalsSchema)(val);
 exports.decoders[constants_1.CODEC.OP_REVEAL] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.RevealSchema)(val);
@@ -56,5 +57,6 @@ exports.decoders[constants_1.CODEC.OP_DRAIN_DELEGATE] = (val) => (0, operation_1
 exports.decoders[constants_1.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.SmartRollupOriginateSchema)(val);
 exports.decoders[constants_1.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.SmartRollupAddMessagesSchema)(val);
 exports.decoders[constants_1.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.SmartRollupExecuteOutboxMessageSchema)(val);
+exports.decoders[constants_1.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.DalPublishCommitmentSchema)(val);
 exports.decoders[constants_1.CODEC.MANAGER] = (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.ManagerOperationSchema);
 exports.decoders[constants_1.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => (0, operation_1.schemaDecoder)(exports.decoders)(operation_1.SetDepositsLimitSchema)(val);

package/dist/lib/encoder.js

@@ -34,6 +34,7 @@ exports.encoders = {
     [constants_1.CODEC.PVM_KIND]: codec_1.pvmKindEncoder,
     [constants_1.CODEC.PADDED_BYTES]: codec_1.paddedBytesEncoder,
     [constants_1.CODEC.SMART_ROLLUP_MESSAGE]: codec_1.smartRollupMessageEncoder,
+    [constants_1.CODEC.SLOT_HEADER]: codec_1.slotHeaderEncoder,
 };
 exports.encoders[constants_1.CODEC.OPERATION] = (0, operation_1.operationEncoder)(exports.encoders);
 exports.encoders[constants_1.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.ActivationSchema)(val);
@@ -42,7 +43,7 @@ exports.encoders[constants_1.CODEC.OP_TRANSACTION] = (val) => (0, operation_1.sc
 exports.encoders[constants_1.CODEC.OP_ORIGINATION] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.OriginationSchema)(val);
 exports.encoders[constants_1.CODEC.OP_BALLOT] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.BallotSchema)(val);
 exports.encoders[constants_1.CODEC.OP_ATTESTATION] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.AttestationSchema)(val);
-exports.encoders[constants_1.CODEC.OP_ENDORSEMENT] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.EndorsementSchema)(val);
+exports.encoders[constants_1.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.AttestationWithDalSchema)(val);
 exports.encoders[constants_1.CODEC.OP_SEED_NONCE_REVELATION] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.SeedNonceRevelationSchema)(val);
 exports.encoders[constants_1.CODEC.OP_PROPOSALS] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.ProposalsSchema)(val);
 exports.encoders[constants_1.CODEC.OP_REVEAL] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.RevealSchema)(val);
@@ -54,6 +55,7 @@ exports.encoders[constants_1.CODEC.OP_DRAIN_DELEGATE] = (val) => (0, operation_1
 exports.encoders[constants_1.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.SmartRollupOriginateSchema)(val);
 exports.encoders[constants_1.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.SmartRollupAddMessagesSchema)(val);
 exports.encoders[constants_1.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.SmartRollupExecuteOutboxMessageSchema)(val);
+exports.encoders[constants_1.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.DalPublishCommitmentSchema)(val);
 exports.encoders[constants_1.CODEC.MANAGER] = (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.ManagerOperationSchema);
 exports.encoders[constants_1.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.SetDepositsLimitSchema)(val);
 exports.encoders[constants_1.CODEC.OP_FAILING_NOOP] = (val) => (0, operation_1.schemaEncoder)(exports.encoders)(operation_1.FailingNoopSchema)(val);

package/dist/lib/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidSmartRollupCommitmentHashError = exports.InvalidSmartRollupAddressError = exports.DecodePvmKindError = exports.UnsupportedPvmKindError = exports.UnsupportedOperationError = exports.OperationEncodingError = exports.OperationDecodingError = exports.UnexpectedMichelsonValueError = exports.DecodeBallotValueError = exports.InvalidBallotValueError = exports.OversizedEntryPointError = exports.InvalidOperationSchemaError = void 0;
+exports.InvalidDalCommitmentError = exports.InvalidSmartRollupCommitmentHashError = exports.InvalidSmartRollupAddressError = exports.DecodePvmKindError = exports.UnsupportedPvmKindError = exports.UnsupportedOperationError = exports.OperationEncodingError = exports.OperationDecodingError = exports.UnexpectedMichelsonValueError = exports.DecodeBallotValueError = exports.InvalidBallotValueError = exports.OversizedEntryPointError = exports.InvalidOperationSchemaError = void 0;
 const core_1 = require("@taquito/core");
 const constants_1 = require("./constants");
 /**
@@ -162,3 +162,18 @@ class InvalidSmartRollupCommitmentHashError extends core_1.ParameterValidationEr
     }
 }
 exports.InvalidSmartRollupCommitmentHashError = InvalidSmartRollupCommitmentHashError;
+/**
+ * @category Error
+ * @description Error that indicates an invalid dal commitment (sh)
+ */
+class InvalidDalCommitmentError extends core_1.ParameterValidationError {
+    constructor(commitment, errorDetail) {
+        super();
+        this.commitment = commitment;
+        this.errorDetail = errorDetail;
+        this.name = 'InvalidDalCommitmentError';
+        this.message = `Invalid dal commitment "${commitment}"`;
+        errorDetail ? (this.message += ` ${errorDetail}.`) : '';
+    }
+}
+exports.InvalidDalCommitmentError = InvalidDalCommitmentError;

package/dist/lib/protocols.js

@@ -21,6 +21,7 @@ var ProtocolsHash;
     ProtocolsHash["PtNairobi"] = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf";
     ProtocolsHash["ProxfordY"] = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH";
     ProtocolsHash["PtParisBQ"] = "PtParisBQscdCm6Cfow6ndeU6wKJyA3aV1j4D3gQBQMsTQyJCrz";
+    ProtocolsHash["PtParisBx"] = "PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ";
     ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(ProtocolsHash || (exports.ProtocolsHash = ProtocolsHash = {}));
 const protoLevel = {
@@ -42,6 +43,7 @@ const protoLevel = {
     PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf: 17,
     ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH: 19,
     PtParisBQscdCm6Cfow6ndeU6wKJyA3aV1j4D3gQBQMsTQyJCrz: 20,
+    PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ: 20,
     ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK: 21,
 };
 function ProtoInferiorTo(a, b) {

package/dist/lib/schema/operation.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaDecoder = exports.schemaEncoder = exports.operationDecoder = exports.operationEncoder = exports.FailingNoopSchema = exports.SmartRollupExecuteOutboxMessageSchema = exports.SmartRollupAddMessagesSchema = exports.SmartRollupOriginateSchema = exports.SetDepositsLimitSchema = exports.DrainDelegateSchema = exports.UpdateConsensusKeySchema = exports.IncreasePaidStorageSchema = exports.TransferTicketSchema = exports.RegisterGlobalConstantSchema = exports.ProposalsSchema = exports.SeedNonceRevelationSchema = exports.EndorsementSchema = exports.AttestationSchema = exports.BallotSchema = exports.OriginationSchema = exports.TransactionSchema = exports.DelegationSchema = exports.RevealSchema = exports.ActivationSchema = exports.ManagerOperationSchema = void 0;
+exports.schemaDecoder = exports.schemaEncoder = exports.operationDecoder = exports.operationEncoder = exports.FailingNoopSchema = exports.DalPublishCommitmentSchema = exports.SmartRollupExecuteOutboxMessageSchema = exports.SmartRollupAddMessagesSchema = exports.SmartRollupOriginateSchema = exports.SetDepositsLimitSchema = exports.DrainDelegateSchema = exports.UpdateConsensusKeySchema = exports.IncreasePaidStorageSchema = exports.TransferTicketSchema = exports.RegisterGlobalConstantSchema = exports.ProposalsSchema = exports.SeedNonceRevelationSchema = exports.AttestationWithDalSchema = exports.AttestationSchema = exports.BallotSchema = exports.OriginationSchema = exports.TransactionSchema = exports.DelegationSchema = exports.RevealSchema = exports.ActivationSchema = exports.ManagerOperationSchema = void 0;
 const constants_1 = require("../constants");
 const core_1 = require("@taquito/core");
 const errors_1 = require("../errors");
@@ -60,11 +60,12 @@ exports.AttestationSchema = {
     round: constants_1.CODEC.INT32,
     block_payload_hash: constants_1.CODEC.BLOCK_PAYLOAD_HASH,
 };
-exports.EndorsementSchema = {
+exports.AttestationWithDalSchema = {
     slot: constants_1.CODEC.INT16,
     level: constants_1.CODEC.INT32,
     round: constants_1.CODEC.INT32,
     block_payload_hash: constants_1.CODEC.BLOCK_PAYLOAD_HASH,
+    dal_attestation: constants_1.CODEC.ZARITH,
 };
 exports.SeedNonceRevelationSchema = {
     level: constants_1.CODEC.INT32,
@@ -155,6 +156,14 @@ exports.SmartRollupExecuteOutboxMessageSchema = {
     cemented_commitment: constants_1.CODEC.SMART_ROLLUP_COMMITMENT_HASH,
     output_proof: constants_1.CODEC.PADDED_BYTES,
 };
+exports.DalPublishCommitmentSchema = {
+    source: constants_1.CODEC.PKH,
+    fee: constants_1.CODEC.ZARITH,
+    counter: constants_1.CODEC.ZARITH,
+    gas_limit: constants_1.CODEC.ZARITH,
+    storage_limit: constants_1.CODEC.ZARITH,
+    slot_header: constants_1.CODEC.SLOT_HEADER,
+};
 exports.FailingNoopSchema = {
     arbitrary: constants_1.CODEC.PADDED_BYTES,
 };

package/dist/lib/taquito-local-forging.js

@@ -40,7 +40,7 @@ var version_1 = require("./version");
 Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
 var protocols_2 = require("./protocols");
 Object.defineProperty(exports, "ProtocolsHash", { enumerable: true, get: function () { return protocols_2.ProtocolsHash; } });
-const PROTOCOL_CURRENT = protocols_1.ProtocolsHash.ProxfordY;
+const PROTOCOL_CURRENT = protocols_1.ProtocolsHash.PtParisBQ;
 function getCodec(codec, _proto) {
     return {
         encoder: encoder_1.encoders[codec],

package/dist/lib/validator.js

@@ -10,7 +10,7 @@ const OperationKindMapping = {
     origination: operation_1.OriginationSchema,
     ballot: operation_1.BallotSchema,
     attestation: operation_1.AttestationSchema,
-    endorsement: operation_1.EndorsementSchema,
+    attestation_with_dal: operation_1.AttestationWithDalSchema,
     seed_nonce_revelation: operation_1.SeedNonceRevelationSchema,
     proposals: operation_1.ProposalsSchema,
     register_global_constant: operation_1.RegisterGlobalConstantSchema,
@@ -22,6 +22,7 @@ const OperationKindMapping = {
     smart_rollup_originate: operation_1.SmartRollupOriginateSchema,
     smart_rollup_add_messages: operation_1.SmartRollupAddMessagesSchema,
     smart_rollup_execute_outbox_message: operation_1.SmartRollupExecuteOutboxMessageSchema,
+    dal_publish_commitment: operation_1.DalPublishCommitmentSchema,
     failing_noop: operation_1.FailingNoopSchema,
 };
 // Asymmetric difference: only account for things in arr2 that are not present in arr1, not vice versa

package/dist/lib/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 exports.VERSION = {
-    "commitHash": "0ef631853ccfda5c5faed584f16069f34085817e",
-    "version": "20.0.0-beta.0"
+    "commitHash": "45fea4a361f29598063e448574800220c4687001",
+    "version": "20.0.0"
 };

package/dist/taquito-local-forging.es6.js

@@ -49,7 +49,7 @@ var CODEC;
     CODEC["OP_BALLOT"] = "ballot";
     CODEC["OP_FAILING_NOOP"] = "failing_noop";
     CODEC["OP_ATTESTATION"] = "attestation";
-    CODEC["OP_ENDORSEMENT"] = "endorsement";
+    CODEC["OP_ATTESTATION_WITH_DAL"] = "attestation_with_dal";
     CODEC["OP_SEED_NONCE_REVELATION"] = "seed_nonce_revelation";
     CODEC["OP_REVEAL"] = "reveal";
     CODEC["OP_PROPOSALS"] = "proposals";
@@ -65,8 +65,10 @@ var CODEC;
     CODEC["PVM_KIND"] = "pvm_kind";
     CODEC["OP_SMART_ROLLUP_ADD_MESSAGES"] = "smart_rollup_add_messages";
     CODEC["OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE"] = "smart_rollup_execute_outbox_message";
+    CODEC["OP_DAL_PUBLISH_COMMITMENT"] = "dal_publish_commitment";
+    CODEC["SLOT_HEADER"] = "slot_header";
 })(CODEC || (CODEC = {}));
-// See https://tezos.gitlab.io/whitedoc/michelson.html#full-grammar
+// See https://tezos.gitlab.io/shell/p2p_api.html#alpha-michelson-v1-primitives-enumeration-unsigned-8-bit-integer
 const opMapping = {
     '00': 'parameter',
     '01': 'storage',
@@ -225,6 +227,7 @@ const opMapping = {
     '9a': 'TICKET',
     '9b': 'BYTES',
     '9c': 'NAT',
+    '9d': 'Ticket',
 };
 const opMappingReverse = (() => {
     const result = {};
@@ -233,7 +236,7 @@ const opMappingReverse = (() => {
     });
     return result;
 })();
-// See https://tezos.gitlab.io/shell/p2p_api.html?highlight=p2p
+// See https://tezos.gitlab.io/shell/p2p_api.html
 const kindMapping = {
     0x04: 'activate_account',
     0x6b: 'reveal',
@@ -242,6 +245,7 @@ const kindMapping = {
     0x6d: 'origination',
     0x06: 'ballot',
     0x15: 'attestation',
+    0x17: 'attestation_with_dal',
     0x01: 'seed_nonce_revelation',
     0x05: 'proposals',
     0x6f: 'register_global_constant',
@@ -253,6 +257,7 @@ const kindMapping = {
     0xc8: 'smart_rollup_originate',
     0xc9: 'smart_rollup_add_messages',
     0xce: 'smart_rollup_execute_outbox_message',
+    0xe6: 'dal_publish_commitment',
     0x11: 'failing_noop',
 };
 const kindMappingReverse = (() => {
@@ -431,6 +436,20 @@ class InvalidSmartRollupCommitmentHashError extends ParameterValidationError {
         errorDetail ? (this.message += ` ${errorDetail}.`) : '';
     }
 }
+/**
+ * @category Error
+ * @description Error that indicates an invalid dal commitment (sh)
+ */
+class InvalidDalCommitmentError extends ParameterValidationError {
+    constructor(commitment, errorDetail) {
+        super();
+        this.commitment = commitment;
+        this.errorDetail = errorDetail;
+        this.name = 'InvalidDalCommitmentError';
+        this.message = `Invalid dal commitment "${commitment}"`;
+        errorDetail ? (this.message += ` ${errorDetail}.`) : '';
+    }
+}
 
 class Uint8ArrayConsumer {
     static fromHexString(hex) {
@@ -1083,7 +1102,7 @@ const parametersEncoder = (val) => {
     }
     const encodedEntrypoint = entrypointEncoder(val.entrypoint);
     const parameters = valueEncoder(val.value);
-    const length = (parameters.length / 2).toString(16).padStart(8, '0');
+    const length = pad(parameters.length / 2);
     return `ff${encodedEntrypoint}${length}${parameters}`;
 };
 const valueParameterEncoder = (value) => {
@@ -1140,6 +1159,31 @@ const smartRollupMessageDecoder = (val) => {
     const ret = stripLengthPrefixFromBytes(new Uint8ArrayConsumer(valueArray));
     return ret.map((value) => Buffer.from(value).toString('hex'));
 };
+const dalCommitmentEncoder = (val) => {
+    const prefix = val.substring(0, 2);
+    if (prefix === Prefix.SH) {
+        return prefixEncoder(Prefix.SH)(val);
+    }
+    throw new InvalidDalCommitmentError(val, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SH}'`);
+};
+const dalCommitmentDecoder = (val) => {
+    const commitment = prefixDecoder(Prefix.SH)(val);
+    if (commitment.substring(0, 2) !== Prefix.SH) {
+        throw new InvalidDalCommitmentError(commitment, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${Prefix.SH}'`);
+    }
+    return commitment;
+};
+const slotHeaderEncoder = (val) => {
+    return pad(val.slot_index, 2) + dalCommitmentEncoder(val.commitment) + val.commitment_proof;
+};
+const slotHeaderDecoder = (val) => {
+    const preamble = val.consume(1);
+    return {
+        slot_index: Number(preamble[0].toString(10)),
+        commitment: dalCommitmentDecoder(val),
+        commitment_proof: toHexString(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
+    };
+};
 
 const ManagerOperationSchema = {
     branch: CODEC.BRANCH,
@@ -1197,11 +1241,12 @@ const AttestationSchema = {
     round: CODEC.INT32,
     block_payload_hash: CODEC.BLOCK_PAYLOAD_HASH,
 };
-const EndorsementSchema = {
+const AttestationWithDalSchema = {
     slot: CODEC.INT16,
     level: CODEC.INT32,
     round: CODEC.INT32,
     block_payload_hash: CODEC.BLOCK_PAYLOAD_HASH,
+    dal_attestation: CODEC.ZARITH,
 };
 const SeedNonceRevelationSchema = {
     level: CODEC.INT32,
@@ -1292,6 +1337,14 @@ const SmartRollupExecuteOutboxMessageSchema = {
     cemented_commitment: CODEC.SMART_ROLLUP_COMMITMENT_HASH,
     output_proof: CODEC.PADDED_BYTES,
 };
+const DalPublishCommitmentSchema = {
+    source: CODEC.PKH,
+    fee: CODEC.ZARITH,
+    counter: CODEC.ZARITH,
+    gas_limit: CODEC.ZARITH,
+    storage_limit: CODEC.ZARITH,
+    slot_header: CODEC.SLOT_HEADER,
+};
 const FailingNoopSchema = {
     arbitrary: CODEC.PADDED_BYTES,
 };
@@ -1389,6 +1442,7 @@ const decoders = {
     [CODEC.PVM_KIND]: pvmKindDecoder,
     [CODEC.PADDED_BYTES]: paddedBytesDecoder,
     [CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder,
+    [CODEC.SLOT_HEADER]: slotHeaderDecoder,
 };
 decoders[CODEC.OPERATION] = operationDecoder(decoders);
 decoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decoders)(ActivationSchema)(val);
@@ -1398,7 +1452,7 @@ decoders[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decoders)(TransactionSch
 decoders[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decoders)(OriginationSchema)(val);
 decoders[CODEC.OP_BALLOT] = (val) => schemaDecoder(decoders)(BallotSchema)(val);
 decoders[CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decoders)(AttestationSchema)(val);
-decoders[CODEC.OP_ENDORSEMENT] = (val) => schemaDecoder(decoders)(EndorsementSchema)(val);
+decoders[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decoders)(AttestationWithDalSchema)(val);
 decoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decoders)(SeedNonceRevelationSchema)(val);
 decoders[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decoders)(ProposalsSchema)(val);
 decoders[CODEC.OP_REVEAL] = (val) => schemaDecoder(decoders)(RevealSchema)(val);
@@ -1410,6 +1464,7 @@ decoders[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaDecoder(decoders)(DrainDelega
 decoders[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decoders)(SmartRollupOriginateSchema)(val);
 decoders[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decoders)(SmartRollupAddMessagesSchema)(val);
 decoders[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+decoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decoders)(DalPublishCommitmentSchema)(val);
 decoders[CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
 decoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decoders)(SetDepositsLimitSchema)(val);
 
@@ -1442,6 +1497,7 @@ const encoders = {
     [CODEC.PVM_KIND]: pvmKindEncoder,
     [CODEC.PADDED_BYTES]: paddedBytesEncoder,
     [CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder,
+    [CODEC.SLOT_HEADER]: slotHeaderEncoder,
 };
 encoders[CODEC.OPERATION] = operationEncoder(encoders);
 encoders[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encoders)(ActivationSchema)(val);
@@ -1450,7 +1506,7 @@ encoders[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encoders)(TransactionSch
 encoders[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encoders)(OriginationSchema)(val);
 encoders[CODEC.OP_BALLOT] = (val) => schemaEncoder(encoders)(BallotSchema)(val);
 encoders[CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encoders)(AttestationSchema)(val);
-encoders[CODEC.OP_ENDORSEMENT] = (val) => schemaEncoder(encoders)(EndorsementSchema)(val);
+encoders[CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encoders)(AttestationWithDalSchema)(val);
 encoders[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encoders)(SeedNonceRevelationSchema)(val);
 encoders[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encoders)(ProposalsSchema)(val);
 encoders[CODEC.OP_REVEAL] = (val) => schemaEncoder(encoders)(RevealSchema)(val);
@@ -1462,6 +1518,7 @@ encoders[CODEC.OP_DRAIN_DELEGATE] = (val) => schemaEncoder(encoders)(DrainDelega
 encoders[CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encoders)(SmartRollupOriginateSchema)(val);
 encoders[CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encoders)(SmartRollupAddMessagesSchema)(val);
 encoders[CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+encoders[CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encoders)(DalPublishCommitmentSchema)(val);
 encoders[CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
 encoders[CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encoders)(SetDepositsLimitSchema)(val);
 encoders[CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encoders)(FailingNoopSchema)(val);
@@ -1474,7 +1531,7 @@ const OperationKindMapping = {
     origination: OriginationSchema,
     ballot: BallotSchema,
     attestation: AttestationSchema,
-    endorsement: EndorsementSchema,
+    attestation_with_dal: AttestationWithDalSchema,
     seed_nonce_revelation: SeedNonceRevelationSchema,
     proposals: ProposalsSchema,
     register_global_constant: RegisterGlobalConstantSchema,
@@ -1486,6 +1543,7 @@ const OperationKindMapping = {
     smart_rollup_originate: SmartRollupOriginateSchema,
     smart_rollup_add_messages: SmartRollupAddMessagesSchema,
     smart_rollup_execute_outbox_message: SmartRollupExecuteOutboxMessageSchema,
+    dal_publish_commitment: DalPublishCommitmentSchema,
     failing_noop: FailingNoopSchema,
 };
 // Asymmetric difference: only account for things in arr2 that are not present in arr1, not vice versa
@@ -1536,20 +1594,21 @@ var ProtocolsHash;
     ProtocolsHash["PtNairobi"] = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf";
     ProtocolsHash["ProxfordY"] = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH";
     ProtocolsHash["PtParisBQ"] = "PtParisBQscdCm6Cfow6ndeU6wKJyA3aV1j4D3gQBQMsTQyJCrz";
+    ProtocolsHash["PtParisBx"] = "PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ";
     ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(ProtocolsHash || (ProtocolsHash = {}));
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "0ef631853ccfda5c5faed584f16069f34085817e",
-    "version": "20.0.0-beta.0"
+    "commitHash": "45fea4a361f29598063e448574800220c4687001",
+    "version": "20.0.0"
 };
 
 /**
  * @packageDocumentation
  * @module @taquito/local-forging
  */
-const PROTOCOL_CURRENT = ProtocolsHash.ProxfordY;
+const PROTOCOL_CURRENT = ProtocolsHash.PtParisBQ;
 function getCodec(codec, _proto) {
     return {
         encoder: encoders[codec],

package/dist/taquito-local-forging.es6.js.map

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

package/dist/taquito-local-forging.umd.js

@@ -51,7 +51,7 @@
       CODEC["OP_BALLOT"] = "ballot";
       CODEC["OP_FAILING_NOOP"] = "failing_noop";
       CODEC["OP_ATTESTATION"] = "attestation";
-      CODEC["OP_ENDORSEMENT"] = "endorsement";
+      CODEC["OP_ATTESTATION_WITH_DAL"] = "attestation_with_dal";
       CODEC["OP_SEED_NONCE_REVELATION"] = "seed_nonce_revelation";
       CODEC["OP_REVEAL"] = "reveal";
       CODEC["OP_PROPOSALS"] = "proposals";
@@ -67,8 +67,10 @@
       CODEC["PVM_KIND"] = "pvm_kind";
       CODEC["OP_SMART_ROLLUP_ADD_MESSAGES"] = "smart_rollup_add_messages";
       CODEC["OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE"] = "smart_rollup_execute_outbox_message";
+      CODEC["OP_DAL_PUBLISH_COMMITMENT"] = "dal_publish_commitment";
+      CODEC["SLOT_HEADER"] = "slot_header";
   })(exports.CODEC || (exports.CODEC = {}));
-  // See https://tezos.gitlab.io/whitedoc/michelson.html#full-grammar
+  // See https://tezos.gitlab.io/shell/p2p_api.html#alpha-michelson-v1-primitives-enumeration-unsigned-8-bit-integer
   const opMapping = {
       '00': 'parameter',
       '01': 'storage',
@@ -227,6 +229,7 @@
       '9a': 'TICKET',
       '9b': 'BYTES',
       '9c': 'NAT',
+      '9d': 'Ticket',
   };
   const opMappingReverse = (() => {
       const result = {};
@@ -235,7 +238,7 @@
       });
       return result;
   })();
-  // See https://tezos.gitlab.io/shell/p2p_api.html?highlight=p2p
+  // See https://tezos.gitlab.io/shell/p2p_api.html
   const kindMapping = {
       0x04: 'activate_account',
       0x6b: 'reveal',
@@ -244,6 +247,7 @@
       0x6d: 'origination',
       0x06: 'ballot',
       0x15: 'attestation',
+      0x17: 'attestation_with_dal',
       0x01: 'seed_nonce_revelation',
       0x05: 'proposals',
       0x6f: 'register_global_constant',
@@ -255,6 +259,7 @@
       0xc8: 'smart_rollup_originate',
       0xc9: 'smart_rollup_add_messages',
       0xce: 'smart_rollup_execute_outbox_message',
+      0xe6: 'dal_publish_commitment',
       0x11: 'failing_noop',
   };
   const kindMappingReverse = (() => {
@@ -433,6 +438,20 @@
           errorDetail ? (this.message += ` ${errorDetail}.`) : '';
       }
   }
+  /**
+   * @category Error
+   * @description Error that indicates an invalid dal commitment (sh)
+   */
+  class InvalidDalCommitmentError extends core.ParameterValidationError {
+      constructor(commitment, errorDetail) {
+          super();
+          this.commitment = commitment;
+          this.errorDetail = errorDetail;
+          this.name = 'InvalidDalCommitmentError';
+          this.message = `Invalid dal commitment "${commitment}"`;
+          errorDetail ? (this.message += ` ${errorDetail}.`) : '';
+      }
+  }
 
   class Uint8ArrayConsumer {
       static fromHexString(hex) {
@@ -1085,7 +1104,7 @@
       }
       const encodedEntrypoint = entrypointEncoder(val.entrypoint);
       const parameters = valueEncoder(val.value);
-      const length = (parameters.length / 2).toString(16).padStart(8, '0');
+      const length = pad(parameters.length / 2);
       return `ff${encodedEntrypoint}${length}${parameters}`;
   };
   const valueParameterEncoder = (value) => {
@@ -1142,6 +1161,31 @@
       const ret = stripLengthPrefixFromBytes(new Uint8ArrayConsumer(valueArray));
       return ret.map((value) => Buffer.from(value).toString('hex'));
   };
+  const dalCommitmentEncoder = (val) => {
+      const prefix = val.substring(0, 2);
+      if (prefix === utils.Prefix.SH) {
+          return prefixEncoder(utils.Prefix.SH)(val);
+      }
+      throw new InvalidDalCommitmentError(val, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SH}'`);
+  };
+  const dalCommitmentDecoder = (val) => {
+      const commitment = prefixDecoder(utils.Prefix.SH)(val);
+      if (commitment.substring(0, 2) !== utils.Prefix.SH) {
+          throw new InvalidDalCommitmentError(commitment, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix '${utils.Prefix.SH}'`);
+      }
+      return commitment;
+  };
+  const slotHeaderEncoder = (val) => {
+      return pad(val.slot_index, 2) + dalCommitmentEncoder(val.commitment) + val.commitment_proof;
+  };
+  const slotHeaderDecoder = (val) => {
+      const preamble = val.consume(1);
+      return {
+          slot_index: Number(preamble[0].toString(10)),
+          commitment: dalCommitmentDecoder(val),
+          commitment_proof: toHexString(val.consume(96)), // rpcForger expect commitment_proof bytes to be len 96
+      };
+  };
 
   const ManagerOperationSchema = {
       branch: exports.CODEC.BRANCH,
@@ -1199,11 +1243,12 @@
       round: exports.CODEC.INT32,
       block_payload_hash: exports.CODEC.BLOCK_PAYLOAD_HASH,
   };
-  const EndorsementSchema = {
+  const AttestationWithDalSchema = {
       slot: exports.CODEC.INT16,
       level: exports.CODEC.INT32,
       round: exports.CODEC.INT32,
       block_payload_hash: exports.CODEC.BLOCK_PAYLOAD_HASH,
+      dal_attestation: exports.CODEC.ZARITH,
   };
   const SeedNonceRevelationSchema = {
       level: exports.CODEC.INT32,
@@ -1294,6 +1339,14 @@
       cemented_commitment: exports.CODEC.SMART_ROLLUP_COMMITMENT_HASH,
       output_proof: exports.CODEC.PADDED_BYTES,
   };
+  const DalPublishCommitmentSchema = {
+      source: exports.CODEC.PKH,
+      fee: exports.CODEC.ZARITH,
+      counter: exports.CODEC.ZARITH,
+      gas_limit: exports.CODEC.ZARITH,
+      storage_limit: exports.CODEC.ZARITH,
+      slot_header: exports.CODEC.SLOT_HEADER,
+  };
   const FailingNoopSchema = {
       arbitrary: exports.CODEC.PADDED_BYTES,
   };
@@ -1391,6 +1444,7 @@
       [exports.CODEC.PVM_KIND]: pvmKindDecoder,
       [exports.CODEC.PADDED_BYTES]: paddedBytesDecoder,
       [exports.CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageDecoder,
+      [exports.CODEC.SLOT_HEADER]: slotHeaderDecoder,
   };
   decoders[exports.CODEC.OPERATION] = operationDecoder(decoders);
   decoders[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decoders)(ActivationSchema)(val);
@@ -1400,7 +1454,7 @@
   decoders[exports.CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decoders)(OriginationSchema)(val);
   decoders[exports.CODEC.OP_BALLOT] = (val) => schemaDecoder(decoders)(BallotSchema)(val);
   decoders[exports.CODEC.OP_ATTESTATION] = (val) => schemaDecoder(decoders)(AttestationSchema)(val);
-  decoders[exports.CODEC.OP_ENDORSEMENT] = (val) => schemaDecoder(decoders)(EndorsementSchema)(val);
+  decoders[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaDecoder(decoders)(AttestationWithDalSchema)(val);
   decoders[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decoders)(SeedNonceRevelationSchema)(val);
   decoders[exports.CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decoders)(ProposalsSchema)(val);
   decoders[exports.CODEC.OP_REVEAL] = (val) => schemaDecoder(decoders)(RevealSchema)(val);
@@ -1412,6 +1466,7 @@
   decoders[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaDecoder(decoders)(SmartRollupOriginateSchema)(val);
   decoders[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaDecoder(decoders)(SmartRollupAddMessagesSchema)(val);
   decoders[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaDecoder(decoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+  decoders[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaDecoder(decoders)(DalPublishCommitmentSchema)(val);
   decoders[exports.CODEC.MANAGER] = schemaDecoder(decoders)(ManagerOperationSchema);
   decoders[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaDecoder(decoders)(SetDepositsLimitSchema)(val);
 
@@ -1444,6 +1499,7 @@
       [exports.CODEC.PVM_KIND]: pvmKindEncoder,
       [exports.CODEC.PADDED_BYTES]: paddedBytesEncoder,
       [exports.CODEC.SMART_ROLLUP_MESSAGE]: smartRollupMessageEncoder,
+      [exports.CODEC.SLOT_HEADER]: slotHeaderEncoder,
   };
   encoders[exports.CODEC.OPERATION] = operationEncoder(encoders);
   encoders[exports.CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encoders)(ActivationSchema)(val);
@@ -1452,7 +1508,7 @@
   encoders[exports.CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encoders)(OriginationSchema)(val);
   encoders[exports.CODEC.OP_BALLOT] = (val) => schemaEncoder(encoders)(BallotSchema)(val);
   encoders[exports.CODEC.OP_ATTESTATION] = (val) => schemaEncoder(encoders)(AttestationSchema)(val);
-  encoders[exports.CODEC.OP_ENDORSEMENT] = (val) => schemaEncoder(encoders)(EndorsementSchema)(val);
+  encoders[exports.CODEC.OP_ATTESTATION_WITH_DAL] = (val) => schemaEncoder(encoders)(AttestationWithDalSchema)(val);
   encoders[exports.CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encoders)(SeedNonceRevelationSchema)(val);
   encoders[exports.CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encoders)(ProposalsSchema)(val);
   encoders[exports.CODEC.OP_REVEAL] = (val) => schemaEncoder(encoders)(RevealSchema)(val);
@@ -1464,6 +1520,7 @@
   encoders[exports.CODEC.OP_SMART_ROLLUP_ORIGINATE] = (val) => schemaEncoder(encoders)(SmartRollupOriginateSchema)(val);
   encoders[exports.CODEC.OP_SMART_ROLLUP_ADD_MESSAGES] = (val) => schemaEncoder(encoders)(SmartRollupAddMessagesSchema)(val);
   encoders[exports.CODEC.OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE] = (val) => schemaEncoder(encoders)(SmartRollupExecuteOutboxMessageSchema)(val);
+  encoders[exports.CODEC.OP_DAL_PUBLISH_COMMITMENT] = (val) => schemaEncoder(encoders)(DalPublishCommitmentSchema)(val);
   encoders[exports.CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
   encoders[exports.CODEC.OP_SET_DEPOSITS_LIMIT] = (val) => schemaEncoder(encoders)(SetDepositsLimitSchema)(val);
   encoders[exports.CODEC.OP_FAILING_NOOP] = (val) => schemaEncoder(encoders)(FailingNoopSchema)(val);
@@ -1476,7 +1533,7 @@
       origination: OriginationSchema,
       ballot: BallotSchema,
       attestation: AttestationSchema,
-      endorsement: EndorsementSchema,
+      attestation_with_dal: AttestationWithDalSchema,
       seed_nonce_revelation: SeedNonceRevelationSchema,
       proposals: ProposalsSchema,
       register_global_constant: RegisterGlobalConstantSchema,
@@ -1488,6 +1545,7 @@
       smart_rollup_originate: SmartRollupOriginateSchema,
       smart_rollup_add_messages: SmartRollupAddMessagesSchema,
       smart_rollup_execute_outbox_message: SmartRollupExecuteOutboxMessageSchema,
+      dal_publish_commitment: DalPublishCommitmentSchema,
       failing_noop: FailingNoopSchema,
   };
   // Asymmetric difference: only account for things in arr2 that are not present in arr1, not vice versa
@@ -1538,20 +1596,21 @@
       ProtocolsHash["PtNairobi"] = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf";
       ProtocolsHash["ProxfordY"] = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH";
       ProtocolsHash["PtParisBQ"] = "PtParisBQscdCm6Cfow6ndeU6wKJyA3aV1j4D3gQBQMsTQyJCrz";
+      ProtocolsHash["PtParisBx"] = "PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ";
       ProtocolsHash["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
   })(exports.ProtocolsHash || (exports.ProtocolsHash = {}));
 
   // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
   const VERSION = {
-      "commitHash": "0ef631853ccfda5c5faed584f16069f34085817e",
-      "version": "20.0.0-beta.0"
+      "commitHash": "45fea4a361f29598063e448574800220c4687001",
+      "version": "20.0.0"
   };
 
   /**
    * @packageDocumentation
    * @module @taquito/local-forging
    */
-  const PROTOCOL_CURRENT = exports.ProtocolsHash.ProxfordY;
+  const PROTOCOL_CURRENT = exports.ProtocolsHash.PtParisBQ;
   function getCodec(codec, _proto) {
       return {
           encoder: encoders[codec],

package/dist/taquito-local-forging.umd.js.map

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

package/dist/types/codec.d.ts

@@ -63,3 +63,15 @@ export declare const paddedBytesEncoder: (val: string, paddingLength?: number) =
 export declare const paddedBytesDecoder: (val: Uint8ArrayConsumer) => string;
 export declare const smartRollupMessageEncoder: (val: string[]) => string;
 export declare const smartRollupMessageDecoder: (val: Uint8ArrayConsumer) => string[];
+export declare const dalCommitmentEncoder: (val: string) => string;
+export declare const dalCommitmentDecoder: (val: Uint8ArrayConsumer) => string;
+export declare const slotHeaderEncoder: (val: {
+    slot_index: number;
+    commitment: string;
+    commitment_proof: string;
+}) => string;
+export declare const slotHeaderDecoder: (val: Uint8ArrayConsumer) => {
+    slot_index: number;
+    commitment: string;
+    commitment_proof: string;
+};

package/dist/types/constants.d.ts

@@ -34,7 +34,7 @@ export declare enum CODEC {
     OP_BALLOT = "ballot",
     OP_FAILING_NOOP = "failing_noop",
     OP_ATTESTATION = "attestation",
-    OP_ENDORSEMENT = "endorsement",
+    OP_ATTESTATION_WITH_DAL = "attestation_with_dal",
     OP_SEED_NONCE_REVELATION = "seed_nonce_revelation",
     OP_REVEAL = "reveal",
     OP_PROPOSALS = "proposals",
@@ -49,7 +49,9 @@ export declare enum CODEC {
     OP_SMART_ROLLUP_ORIGINATE = "smart_rollup_originate",
     PVM_KIND = "pvm_kind",
     OP_SMART_ROLLUP_ADD_MESSAGES = "smart_rollup_add_messages",
-    OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE = "smart_rollup_execute_outbox_message"
+    OP_SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE = "smart_rollup_execute_outbox_message",
+    OP_DAL_PUBLISH_COMMITMENT = "dal_publish_commitment",
+    SLOT_HEADER = "slot_header"
 }
 export declare const opMapping: {
     [key: string]: string;

package/dist/types/errors.d.ts

@@ -98,3 +98,12 @@ export declare class InvalidSmartRollupCommitmentHashError extends ParameterVali
     readonly errorDetail?: string | undefined;
     constructor(hash: string, errorDetail?: string | undefined);
 }
+/**
+ * @category Error
+ * @description Error that indicates an invalid dal commitment (sh)
+ */
+export declare class InvalidDalCommitmentError extends ParameterValidationError {
+    readonly commitment: string;
+    readonly errorDetail?: string | undefined;
+    constructor(commitment: string, errorDetail?: string | undefined);
+}

package/dist/types/protocols.d.ts

@@ -17,6 +17,7 @@ export declare enum ProtocolsHash {
     PtNairobi = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf",
     ProxfordY = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH",
     PtParisBQ = "PtParisBQscdCm6Cfow6ndeU6wKJyA3aV1j4D3gQBQMsTQyJCrz",
+    PtParisBx = "PtParisBxoLz5gzMmn3d9WBQNoPSZakgnkMC2VNuQ3KXfUtUQeZ",
     ProtoALpha = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK"
 }
 export declare function ProtoInferiorTo(a: ProtocolsHash, b: ProtocolsHash): boolean;

package/dist/types/schema/operation.d.ts

@@ -57,11 +57,12 @@ export declare const AttestationSchema: {
     round: CODEC;
     block_payload_hash: CODEC;
 };
-export declare const EndorsementSchema: {
+export declare const AttestationWithDalSchema: {
     slot: CODEC;
     level: CODEC;
     round: CODEC;
     block_payload_hash: CODEC;
+    dal_attestation: CODEC;
 };
 export declare const SeedNonceRevelationSchema: {
     level: CODEC;
@@ -152,6 +153,14 @@ export declare const SmartRollupExecuteOutboxMessageSchema: {
     cemented_commitment: CODEC;
     output_proof: CODEC;
 };
+export declare const DalPublishCommitmentSchema: {
+    source: CODEC;
+    fee: CODEC;
+    counter: CODEC;
+    gas_limit: CODEC;
+    storage_limit: CODEC;
+    slot_header: CODEC;
+};
 export declare const FailingNoopSchema: {
     arbitrary: CODEC;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/local-forging",
-  "version": "20.0.0-beta.0",
+  "version": "20.0.0",
   "description": "Provide local forging functionality to be with taquito",
   "keywords": [
     "tezos",
@@ -67,12 +67,12 @@
     ]
   },
   "dependencies": {
-    "@taquito/core": "^20.0.0-beta.0",
-    "@taquito/utils": "^20.0.0-beta.0",
+    "@taquito/core": "^20.0.0",
+    "@taquito/utils": "^20.0.0",
     "bignumber.js": "^9.1.2"
   },
   "devDependencies": {
-    "@taquito/rpc": "^20.0.0-beta.0",
+    "@taquito/rpc": "^20.0.0",
     "@types/bluebird": "^3.5.40",
     "@types/estree": "^1.0.2",
     "@types/jest": "^29.5.5",
@@ -104,5 +104,5 @@
     "webpack": "^5.89.0",
     "webpack-cli": "^5.1.4"
   },
-  "gitHead": "88980709574468fad5e4e7d63d34e1d71accf550"
+  "gitHead": "4871f03155be8dfce81ff24cb45fe0e3049c7646"
 }