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

package/dist/lib/taquito-http-utils/src/transport-errors.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Cross-runtime transport error classifier.
+ *
+ * Inspects structural properties first (err.code, err.cause.code, err.name),
+ * falls back to message substring matching only when structure isn't enough.
+ * Handles node-fetch FetchError, native fetch/undici TypeError + cause chain,
+ * browser TypeError, Deno, and Bun error shapes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyTransportError = classifyTransportError;
+const MAY_HAVE_REACHED = {
+    abort: false,
+    dns: false,
+    connect: false,
+    socket: true,
+    tls: false,
+    timeout: true,
+    network: true,
+};
+function extractCode(err) {
+    if (typeof err !== 'object' || err === null)
+        return undefined;
+    const code = err['code'];
+    return typeof code === 'string' ? code : undefined;
+}
+function extractCause(err) {
+    if (typeof err !== 'object' || err === null)
+        return undefined;
+    return err['cause'];
+}
+function extractCauseCode(err) {
+    return extractCode(extractCause(err));
+}
+function extractCauseMessage(err) {
+    const cause = extractCause(err);
+    if (typeof cause === 'object' && cause !== null) {
+        const msg = cause['message'];
+        if (typeof msg === 'string')
+            return msg.toLowerCase();
+    }
+    return '';
+}
+function classify(kind, err) {
+    return { kind, mayHaveReachedServer: MAY_HAVE_REACHED[kind], original: err };
+}
+/**
+ * Classify a thrown value as a transport-level error.
+ *
+ * Inspects structural properties first (err.code, err.cause.code, err.name),
+ * then falls back to message substring matching. Handles node-fetch FetchError,
+ * native fetch/undici TypeError + cause chain, browser TypeError, Deno, and Bun.
+ *
+ * @returns the classification, or `undefined` if the error is not transport-related.
+ */
+function classifyTransportError(err) {
+    if (!(err instanceof Error))
+        return undefined;
+    const code = extractCode(err);
+    const causeCode = extractCauseCode(err);
+    const msg = err.message.toLowerCase();
+    const causeMsg = extractCauseMessage(err);
+    // 1. AbortError (our timeout or caller cancel)
+    if (err.name === 'AbortError') {
+        return classify('abort', err);
+    }
+    // 2. DNS resolution failure
+    if (code === 'ENOTFOUND' ||
+        code === 'EAI_AGAIN' ||
+        causeCode === 'ENOTFOUND' ||
+        causeCode === 'EAI_AGAIN' ||
+        msg.includes('enotfound') ||
+        msg.includes('eai_again')) {
+        return classify('dns', err);
+    }
+    // 3. Connection refused / connect timeout
+    if (code === 'ECONNREFUSED' ||
+        causeCode === 'ECONNREFUSED' ||
+        causeCode === 'UND_ERR_CONNECT_TIMEOUT' ||
+        msg.includes('econnrefused')) {
+        return classify('connect', err);
+    }
+    // 4. TLS errors (check before socket/timeout since TLS errors can also set ECONNRESET)
+    // Also inspect cause.message for native fetch which wraps TLS errors in TypeError("fetch failed")
+    if (msg.includes('certificate') ||
+        msg.includes('self signed') ||
+        msg.includes('ssl') ||
+        msg.includes('handshake') ||
+        causeMsg.includes('certificate') ||
+        causeMsg.includes('self signed') ||
+        causeMsg.includes('ssl') ||
+        causeMsg.includes('handshake')) {
+        return classify('tls', err);
+    }
+    // 5. TCP/connect timeout and undici header/body timeouts
+    if (code === 'ETIMEDOUT' ||
+        causeCode === 'ETIMEDOUT' ||
+        causeCode === 'UND_ERR_HEADERS_TIMEOUT' ||
+        causeCode === 'UND_ERR_BODY_TIMEOUT' ||
+        msg.includes('etimedout') ||
+        msg.includes('timed out')) {
+        return classify('timeout', err);
+    }
+    // 6. Socket-level errors (connection was established or partially established)
+    if (code === 'ECONNRESET' ||
+        causeCode === 'ECONNRESET' ||
+        causeCode === 'UND_ERR_SOCKET' ||
+        msg.includes('econnreset') ||
+        msg.includes('socket hang up') ||
+        msg.includes('other side closed') ||
+        msg.includes('closed unexpectedly') ||
+        msg.includes('connection reset')) {
+        return classify('socket', err);
+    }
+    // 7. Generic fetch failure (browser TypeError, undici wrapper)
+    // "terminated" is undici's wrapper for body-read failures (e.g. response.json() after socket drop)
+    if (err instanceof TypeError &&
+        (msg.includes('fetch failed') ||
+            msg.includes('failed to fetch') ||
+            msg.includes('network error') ||
+            msg.includes('error sending request') ||
+            msg === 'terminated')) {
+        return classify('network', err);
+    }
+    // 8. Remaining node-fetch FetchError.
+    // Transport types: 'system' (OS-level), 'request-timeout', 'body-timeout'.
+    // Non-transport types: 'invalid-json', 'no-redirect', 'max-size'.
+    if (err.name === 'FetchError') {
+        const fetchType = err['type'];
+        if (fetchType === 'request-timeout' || fetchType === 'body-timeout') {
+            return classify('timeout', err);
+        }
+        if (fetchType === 'system') {
+            return classify('network', err);
+        }
+        // Not a transport error (e.g. JSON parse failure on a 200 response)
+        return undefined;
+    }
+    // Not a transport error
+    return undefined;
+}

package/dist/lib/{version.js → taquito-http-utils/src/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!
 exports.VERSION = {
-    "commitHash": "05df48fee92f846cba793920d6fa829afd6a1847",
-    "version": "24.3.0-beta.1"
+    "commitHash": "fb73f1546d3dff2fbba7741ca6006680212bef16",
+    "version": "24.3.0-beta.2"
 };

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

@@ -0,0 +1,543 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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.slotHeaderDecoder = exports.slotHeaderEncoder = exports.dalCommitmentDecoder = exports.dalCommitmentEncoder = exports.smartRollupMessageDecoder = exports.smartRollupMessageEncoder = exports.paddedBytesDecoder = exports.paddedBytesEncoder = exports.signatureProofDecoder = exports.signatureProofEncoder = exports.depositsLimitDecoder = exports.depositsLimitEncoder = void 0;
+const utils_1 = require("@taquito/utils");
+const errors_1 = require("./errors");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const constants_1 = require("./constants");
+const codec_1 = require("./michelson/codec");
+const uint8array_consumer_1 = require("./uint8array-consumer");
+const utils_2 = require("./utils");
+const core_1 = require("@taquito/core");
+// https://tezos.gitlab.io/shell/p2p_api.html specifies data types and structure for forging
+const prefixEncoder = (prefix) => (str) => {
+    const [pl] = (0, utils_1.b58DecodeAndCheckPrefix)(str, [prefix]);
+    return (0, utils_1.buf2hex)(pl);
+};
+exports.prefixEncoder = prefixEncoder;
+const prefixDecoder = (pre) => (str) => {
+    const val = str.consume(utils_1.payloadLength[pre]);
+    return (0, utils_1.b58Encode)(val, pre);
+};
+exports.prefixDecoder = prefixDecoder;
+exports.tz1Decoder = (0, exports.prefixDecoder)(utils_1.PrefixV2.Ed25519PublicKeyHash);
+exports.branchDecoder = (0, exports.prefixDecoder)(utils_1.PrefixV2.BlockHash);
+const publicKeyHashDecoder = (val) => {
+    const prefix = val.consume(1);
+    if (prefix[0] === 0x00) {
+        return (0, exports.prefixDecoder)(utils_1.PrefixV2.Ed25519PublicKeyHash)(val);
+    }
+    else if (prefix[0] === 0x01) {
+        return (0, exports.prefixDecoder)(utils_1.PrefixV2.Secp256k1PublicKeyHash)(val);
+    }
+    else if (prefix[0] === 0x02) {
+        return (0, exports.prefixDecoder)(utils_1.PrefixV2.P256PublicKeyHash)(val);
+    }
+    else if (prefix[0] === 0x03) {
+        return (0, exports.prefixDecoder)(utils_1.PrefixV2.BLS12_381PublicKeyHash)(val);
+    }
+};
+exports.publicKeyHashDecoder = publicKeyHashDecoder;
+const publicKeyHashesDecoder = (val) => {
+    if (!(0, exports.boolDecoder)(val)) {
+        return;
+    }
+    const publicKeyHashes = [];
+    val.consume(4);
+    while (val.length() > 0) {
+        publicKeyHashes.push((0, exports.publicKeyHashDecoder)(val));
+    }
+    return publicKeyHashes;
+};
+exports.publicKeyHashesDecoder = publicKeyHashesDecoder;
+exports.branchEncoder = (0, exports.prefixEncoder)(utils_1.PrefixV2.BlockHash);
+exports.tz1Encoder = (0, exports.prefixEncoder)(utils_1.PrefixV2.Ed25519PublicKeyHash);
+const boolEncoder = (bool) => (bool ? 'ff' : '00');
+exports.boolEncoder = boolEncoder;
+const proposalEncoder = (proposal) => {
+    return (0, exports.prefixEncoder)(utils_1.PrefixV2.ProtocolHash)(proposal);
+};
+exports.proposalEncoder = proposalEncoder;
+const proposalDecoder = (proposal) => {
+    return (0, exports.prefixDecoder)(utils_1.PrefixV2.ProtocolHash)(proposal);
+};
+exports.proposalDecoder = proposalDecoder;
+const proposalsDecoder = (proposal) => {
+    const proposals = [];
+    proposal.consume(4);
+    while (proposal.length() > 0) {
+        proposals.push((0, exports.proposalDecoder)(proposal));
+    }
+    return proposals;
+};
+exports.proposalsDecoder = proposalsDecoder;
+const proposalsEncoder = (proposals) => {
+    return (0, utils_2.pad)(32 * proposals.length) + proposals.map((x) => (0, exports.proposalEncoder)(x)).join('');
+};
+exports.proposalsEncoder = proposalsEncoder;
+const ballotEncoder = (ballot) => {
+    switch (ballot) {
+        case 'yay':
+            return '00';
+        case 'nay':
+            return '01';
+        case 'pass':
+            return '02';
+        default:
+            throw new errors_1.InvalidBallotValueError(ballot);
+    }
+};
+exports.ballotEncoder = ballotEncoder;
+const ballotDecoder = (ballot) => {
+    const value = ballot.consume(1);
+    switch (value[0]) {
+        case 0x00:
+            return 'yay';
+        case 0x01:
+            return 'nay';
+        case 0x02:
+            return 'pass';
+        default:
+            throw new errors_1.DecodeBallotValueError(value[0].toString());
+    }
+};
+exports.ballotDecoder = ballotDecoder;
+const pvmKindEncoder = (pvm) => {
+    switch (pvm) {
+        case 'arith':
+            return '00';
+        case 'wasm_2_0_0':
+            return '01';
+        case 'riscv':
+            return '02';
+        default:
+            throw new errors_1.UnsupportedPvmKindError(pvm);
+    }
+};
+exports.pvmKindEncoder = pvmKindEncoder;
+const pvmKindDecoder = (pvm) => {
+    const value = pvm.consume(1);
+    switch (value[0]) {
+        case 0x00:
+            return 'arith';
+        case 0x01:
+            return 'wasm_2_0_0';
+        case 0x02:
+            return 'riscv';
+        default:
+            throw new errors_1.DecodePvmKindError(value[0].toString());
+    }
+};
+exports.pvmKindDecoder = pvmKindDecoder;
+const delegateEncoder = (val) => {
+    if (val) {
+        return (0, exports.boolEncoder)(true) + (0, exports.publicKeyHashEncoder)(val);
+    }
+    else {
+        return (0, exports.boolEncoder)(false);
+    }
+};
+exports.delegateEncoder = delegateEncoder;
+const int32Encoder = (val) => {
+    const num = parseInt(String(val), 10);
+    const byte = [];
+    for (let i = 0; i < 4; i++) {
+        const shiftBy = (4 - (i + 1)) * 8;
+        byte.push((num & (0xff << shiftBy)) >> shiftBy);
+    }
+    return Buffer.from(byte).toString('hex');
+};
+exports.int32Encoder = int32Encoder;
+const int32Decoder = (val) => {
+    const num = val.consume(4);
+    let finalNum = 0;
+    for (let i = 0; i < num.length; i++) {
+        finalNum = finalNum | (num[i] << ((num.length - (i + 1)) * 8));
+    }
+    return finalNum;
+};
+exports.int32Decoder = int32Decoder;
+const int16Encoder = (val) => {
+    const num = parseInt(String(val), 10);
+    const byte = [];
+    for (let i = 0; i < 2; i++) {
+        const shiftBy = (2 - (i + 1)) * 8;
+        byte.push((num & (0xff << shiftBy)) >> shiftBy);
+    }
+    return Buffer.from(byte).toString('hex');
+};
+exports.int16Encoder = int16Encoder;
+const int16Decoder = (val) => {
+    const num = val.consume(2);
+    let finalNum = 0;
+    for (let i = 0; i < num.length; i++) {
+        finalNum = finalNum | (num[i] << ((num.length - (i + 1)) * 8));
+    }
+    return finalNum;
+};
+exports.int16Decoder = int16Decoder;
+const boolDecoder = (val) => {
+    const bool = val.consume(1);
+    return bool[0] === 0xff;
+};
+exports.boolDecoder = boolDecoder;
+const delegateDecoder = (val) => {
+    const hasDelegate = (0, exports.boolDecoder)(val);
+    if (hasDelegate) {
+        return (0, exports.publicKeyHashDecoder)(val);
+    }
+};
+exports.delegateDecoder = delegateDecoder;
+const publicKeyHashEncoder = (val) => {
+    try {
+        return (0, utils_1.b58DecodePublicKeyHash)(val);
+    }
+    catch (err) {
+        throw new core_1.InvalidKeyHashError(val, err instanceof core_1.ParameterValidationError ? err.result : undefined);
+    }
+};
+exports.publicKeyHashEncoder = publicKeyHashEncoder;
+const publicKeyHashesEncoder = (val) => {
+    if (!val) {
+        return (0, exports.boolEncoder)(false);
+    }
+    if (val.length === 0) {
+        return (0, exports.boolEncoder)(true) + (0, utils_2.pad)(0);
+    }
+    const publicKeyHashes = val.reduce((prev, curr) => {
+        return prev + (0, exports.publicKeyHashEncoder)(curr);
+    }, '');
+    return (0, exports.boolEncoder)(true) + (0, utils_2.pad)(publicKeyHashes.length / 2) + publicKeyHashes;
+};
+exports.publicKeyHashesEncoder = publicKeyHashesEncoder;
+const publicKeyEncoder = (val) => {
+    try {
+        return (0, utils_1.b58DecodePublicKey)(val);
+    }
+    catch (err) {
+        throw new utils_1.InvalidPublicKeyError(val, err instanceof core_1.ParameterValidationError ? err.result : undefined);
+    }
+};
+exports.publicKeyEncoder = publicKeyEncoder;
+const addressEncoder = (val) => {
+    return (0, utils_1.b58DecodeAddress)(val);
+};
+exports.addressEncoder = addressEncoder;
+const smartRollupAddressEncoder = (val) => {
+    try {
+        return (0, exports.prefixEncoder)(utils_1.PrefixV2.SmartRollupHash)(val);
+    }
+    catch (err) {
+        if (err instanceof core_1.ParameterValidationError) {
+            throw new errors_1.InvalidSmartRollupAddressError(val);
+        }
+        else {
+            throw err;
+        }
+    }
+};
+exports.smartRollupAddressEncoder = smartRollupAddressEncoder;
+const smartContractAddressEncoder = (val) => (0, utils_1.b58DecodeAddress)(val);
+exports.smartContractAddressEncoder = smartContractAddressEncoder;
+const publicKeyDecoder = (val) => {
+    const preamble = val.consume(1);
+    switch (preamble[0]) {
+        case 0x00:
+            return (0, exports.prefixDecoder)(utils_1.PrefixV2.Ed25519PublicKey)(val);
+        case 0x01:
+            return (0, exports.prefixDecoder)(utils_1.PrefixV2.Secp256k1PublicKey)(val);
+        case 0x02:
+            return (0, exports.prefixDecoder)(utils_1.PrefixV2.P256PublicKey)(val);
+        case 0x03:
+            return (0, exports.prefixDecoder)(utils_1.PrefixV2.BLS12_381PublicKey)(val);
+        default:
+            throw new utils_1.InvalidPublicKeyError(undefined, utils_1.ValidationResult.NO_PREFIX_MATCHED);
+    }
+};
+exports.publicKeyDecoder = publicKeyDecoder;
+const smartRollupCommitmentHashEncoder = (val) => {
+    try {
+        return (0, exports.prefixEncoder)(utils_1.PrefixV2.SmartRollupCommitmentHash)(val);
+    }
+    catch (err) {
+        if (err instanceof core_1.ParameterValidationError) {
+            throw new errors_1.InvalidSmartRollupCommitmentHashError(val);
+        }
+        else {
+            throw err;
+        }
+    }
+};
+exports.smartRollupCommitmentHashEncoder = smartRollupCommitmentHashEncoder;
+const addressDecoder = (val) => {
+    const preamble = val.consume(1);
+    switch (preamble[0]) {
+        case 0x00:
+            return (0, exports.publicKeyHashDecoder)(val);
+        case 0x01: {
+            const address = (0, exports.prefixDecoder)(utils_1.PrefixV2.ContractHash)(val);
+            val.consume(1);
+            return address;
+        }
+        default:
+            throw new core_1.InvalidAddressError(val.toString(), ': Unable to decode.');
+    }
+};
+exports.addressDecoder = addressDecoder;
+const smartRollupAddressDecoder = (val) => {
+    return (0, exports.prefixDecoder)(utils_1.PrefixV2.SmartRollupHash)(val);
+};
+exports.smartRollupAddressDecoder = smartRollupAddressDecoder;
+const smartContractAddressDecoder = (val) => {
+    const preamble = val.consume(1);
+    if (preamble[0] === 0x01) {
+        const scAddress = (0, exports.prefixDecoder)(utils_1.PrefixV2.ContractHash)(val);
+        val.consume(1);
+        return scAddress;
+    }
+    throw new core_1.InvalidContractAddressError(val.toString(), utils_1.ValidationResult.NO_PREFIX_MATCHED);
+};
+exports.smartContractAddressDecoder = smartContractAddressDecoder;
+const smartRollupCommitmentHashDecoder = (val) => {
+    return (0, exports.prefixDecoder)(utils_1.PrefixV2.SmartRollupCommitmentHash)(val);
+};
+exports.smartRollupCommitmentHashDecoder = smartRollupCommitmentHashDecoder;
+const zarithEncoder = (n) => {
+    const fn = [];
+    let nn = new bignumber_js_1.default(n, 10);
+    if (nn.isNaN()) {
+        throw new TypeError(`Invalid zarith number ${n}`);
+    }
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (nn.lt(128)) {
+            if (nn.lt(16))
+                fn.push('0');
+            fn.push(nn.toString(16));
+            break;
+        }
+        else {
+            let b = nn.mod(128);
+            nn = nn.minus(b);
+            nn = nn.dividedBy(128);
+            b = b.plus(128);
+            fn.push(b.toString(16));
+        }
+    }
+    return fn.join('');
+};
+exports.zarithEncoder = zarithEncoder;
+const zarithDecoder = (n) => {
+    let mostSignificantByte = 0;
+    while (mostSignificantByte < n.length() && (n.get(mostSignificantByte) & 128) !== 0) {
+        mostSignificantByte += 1;
+    }
+    let num = new bignumber_js_1.default(0);
+    for (let i = mostSignificantByte; i >= 0; i -= 1) {
+        const tmp = n.get(i) & 0x7f;
+        num = num.multipliedBy(128);
+        num = num.plus(tmp);
+    }
+    n.consume(mostSignificantByte + 1);
+    return new bignumber_js_1.default(num).toString();
+};
+exports.zarithDecoder = zarithDecoder;
+const entrypointDecoder = (value) => {
+    const preamble = (0, utils_2.pad)(value.consume(1)[0], 2);
+    if (preamble in constants_1.entrypointMapping) {
+        return constants_1.entrypointMapping[preamble];
+    }
+    else {
+        const entry = (0, codec_1.extractRequiredLen)(value, 1);
+        const entrypoint = Buffer.from(entry).toString('utf8');
+        if (entrypoint.length > constants_1.ENTRYPOINT_MAX_LENGTH) {
+            throw new errors_1.OversizedEntryPointError(entrypoint);
+        }
+        return entrypoint;
+    }
+};
+exports.entrypointDecoder = entrypointDecoder;
+const parametersDecoder = (val) => {
+    const preamble = val.consume(1);
+    if (preamble[0] === 0x00) {
+        return;
+    }
+    else {
+        const encodedEntrypoint = (0, exports.entrypointDecoder)(val);
+        const params = (0, codec_1.extractRequiredLen)(val);
+        const parameters = (0, codec_1.valueDecoder)(new uint8array_consumer_1.Uint8ArrayConsumer(params));
+        return {
+            entrypoint: encodedEntrypoint,
+            value: parameters,
+        };
+    }
+};
+exports.parametersDecoder = parametersDecoder;
+const entrypointEncoder = (entrypoint) => {
+    if (entrypoint in constants_1.entrypointMappingReverse) {
+        return `${constants_1.entrypointMappingReverse[entrypoint]}`;
+    }
+    else {
+        if (entrypoint.length > constants_1.ENTRYPOINT_MAX_LENGTH) {
+            throw new errors_1.OversizedEntryPointError(entrypoint);
+        }
+        const value = { string: entrypoint };
+        return `ff${(0, codec_1.valueEncoder)(value).slice(8)}`;
+    }
+};
+exports.entrypointEncoder = entrypointEncoder;
+const parametersEncoder = (val) => {
+    if (!val || (val.entrypoint === 'default' && 'prim' in val.value && val.value.prim === 'Unit')) {
+        return '00';
+    }
+    const encodedEntrypoint = (0, exports.entrypointEncoder)(val.entrypoint);
+    const parameters = (0, codec_1.valueEncoder)(val.value);
+    const length = (0, utils_2.pad)(parameters.length / 2);
+    return `ff${encodedEntrypoint}${length}${parameters}`;
+};
+exports.parametersEncoder = parametersEncoder;
+const valueParameterEncoder = (value) => {
+    const valueEncoded = (0, codec_1.valueEncoder)(value);
+    return `${(0, utils_2.pad)(valueEncoded.length / 2)}${valueEncoded}`;
+};
+exports.valueParameterEncoder = valueParameterEncoder;
+const valueParameterDecoder = (val) => {
+    const value = (0, codec_1.extractRequiredLen)(val);
+    return (0, codec_1.valueDecoder)(new uint8array_consumer_1.Uint8ArrayConsumer(value));
+};
+exports.valueParameterDecoder = valueParameterDecoder;
+exports.blockPayloadHashEncoder = (0, exports.prefixEncoder)(utils_1.PrefixV2.ValueHash);
+exports.blockPayloadHashDecoder = (0, exports.prefixDecoder)(utils_1.PrefixV2.ValueHash);
+const entrypointNameEncoder = (entrypoint) => {
+    const value = { string: entrypoint };
+    return `${(0, codec_1.valueEncoder)(value).slice(2)}`;
+};
+exports.entrypointNameEncoder = entrypointNameEncoder;
+const entrypointNameDecoder = (val) => {
+    const entry = (0, codec_1.extractRequiredLen)(val);
+    return Buffer.from(entry).toString('utf8');
+};
+exports.entrypointNameDecoder = entrypointNameDecoder;
+const burnLimitEncoder = (val) => {
+    return !val ? '00' : `ff${(0, exports.zarithEncoder)(val)}`;
+};
+exports.burnLimitEncoder = burnLimitEncoder;
+const burnLimitDecoder = (value) => {
+    const prefix = value.consume(1);
+    if (Buffer.from(prefix).toString('hex') !== '00') {
+        return (0, exports.zarithDecoder)(value);
+    }
+};
+exports.burnLimitDecoder = burnLimitDecoder;
+const depositsLimitEncoder = (val) => {
+    return !val ? '00' : `ff${(0, exports.zarithEncoder)(val)}`;
+};
+exports.depositsLimitEncoder = depositsLimitEncoder;
+const depositsLimitDecoder = (value) => {
+    const prefix = value.consume(1);
+    if (Buffer.from(prefix).toString('hex') !== '00') {
+        return (0, exports.zarithDecoder)(value);
+    }
+};
+exports.depositsLimitDecoder = depositsLimitDecoder;
+const signatureV1Encoder = (val) => {
+    try {
+        const [data, pre] = (0, utils_1.b58DecodeAndCheckPrefix)(val, utils_1.signaturePrefixes);
+        if (pre === utils_1.PrefixV2.BLS12_381Signature) {
+            return (0, exports.paddedBytesEncoder)((0, utils_1.buf2hex)(data));
+        }
+        else {
+            throw new core_1.ProhibitedActionError('we only support encoding of BLSIG signatures from protocol Seoul');
+        }
+    }
+    catch (err) {
+        if (err instanceof core_1.ParameterValidationError) {
+            throw new core_1.InvalidSignatureError(val, err.result);
+        }
+        else {
+            throw err;
+        }
+    }
+};
+const signatureV1Decoder = (val) => {
+    val.consume(4);
+    if (val.length().toString() === '96') {
+        return (0, exports.prefixDecoder)(utils_1.PrefixV2.BLS12_381Signature)(val);
+    }
+    else {
+        throw new core_1.ProhibitedActionError('we only support decoding of BLSIG signatures');
+    }
+};
+const signatureProofEncoder = (val) => {
+    if (val) {
+        return (0, exports.boolEncoder)(true) + signatureV1Encoder(val);
+    }
+    else {
+        return (0, exports.boolEncoder)(false);
+    }
+};
+exports.signatureProofEncoder = signatureProofEncoder;
+const signatureProofDecoder = (value) => {
+    const hasProof = (0, exports.boolDecoder)(value);
+    if (hasProof) {
+        return signatureV1Decoder(value);
+    }
+};
+exports.signatureProofDecoder = signatureProofDecoder;
+const paddedBytesEncoder = (val, paddingLength = 8) => {
+    return `${(0, utils_2.pad)(val.length / 2, paddingLength)}${val}`;
+};
+exports.paddedBytesEncoder = paddedBytesEncoder;
+const paddedBytesDecoder = (val) => {
+    const value = (0, codec_1.extractRequiredLen)(val);
+    return Buffer.from(value).toString('hex');
+};
+exports.paddedBytesDecoder = paddedBytesDecoder;
+const smartRollupMessageEncoder = (val) => {
+    const message = val.reduce((prev, curr) => {
+        return prev + `${(0, utils_2.pad)(curr.length / 2)}${curr}`;
+    }, '');
+    return `${(0, utils_2.pad)(message.length / 2)}${message}`;
+};
+exports.smartRollupMessageEncoder = smartRollupMessageEncoder;
+const smartRollupMessageDecoder = (val) => {
+    const valueArray = (0, codec_1.extractRequiredLen)(val);
+    const ret = (0, codec_1.stripLengthPrefixFromBytes)(new uint8array_consumer_1.Uint8ArrayConsumer(valueArray));
+    return ret.map((value) => Buffer.from(value).toString('hex'));
+};
+exports.smartRollupMessageDecoder = smartRollupMessageDecoder;
+const dalCommitmentEncoder = (val) => {
+    try {
+        return (0, exports.prefixEncoder)(utils_1.PrefixV2.SlotHeader)(val);
+    }
+    catch (err) {
+        if (err instanceof core_1.ParameterValidationError) {
+            throw new errors_1.InvalidDalCommitmentError(val);
+        }
+        else {
+            throw err;
+        }
+    }
+};
+exports.dalCommitmentEncoder = dalCommitmentEncoder;
+const dalCommitmentDecoder = (val) => {
+    return (0, exports.prefixDecoder)(utils_1.PrefixV2.SlotHeader)(val);
+};
+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;