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

package/dist/lib/taquito-signer/src/in-memory-signer.js

@@ -0,0 +1,240 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _InMemorySigner_key;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemorySigner = void 0;
+exports.publicKeyFromString = publicKeyFromString;
+const nacl_1 = require("@stablelib/nacl");
+const utils_1 = require("@taquito/utils");
+const typedarray_to_buffer_1 = __importDefault(require("typedarray-to-buffer"));
+const ed_key_1 = require("./ed-key");
+const ec_key_1 = require("./ec-key");
+const bip39 = __importStar(require("@scure/bip39"));
+const english_js_1 = require("@scure/bip39/wordlists/english.js");
+const pbkdf2_js_1 = require("@noble/hashes/pbkdf2.js");
+const helpers_1 = require("./helpers");
+const errors_1 = require("./errors");
+const core_1 = require("@taquito/core");
+const key_interface_1 = require("./key-interface");
+const bls_key_1 = require("./bls-key");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+/**
+ * A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
+ *
+ * @remarks If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
+ * @throws InvalidMnemonicError
+ */
+class InMemorySigner {
+    static fromFundraiser(email, password, mnemonic) {
+        if (!bip39.validateMnemonic(mnemonic, english_js_1.wordlist)) {
+            throw new errors_1.InvalidMnemonicError();
+        }
+        const seed = bip39.mnemonicToSeedSync(mnemonic, `${email}${password}`);
+        const key = (0, utils_1.b58Encode)(seed.subarray(0, 32), utils_1.PrefixV2.Ed25519Seed);
+        return new InMemorySigner(key);
+    }
+    static async fromSecretKey(key, passphrase) {
+        return new InMemorySigner(key, passphrase);
+    }
+    /**
+     *
+     * Instantiation of an InMemorySigner instance from a mnemonic
+     * @returns InMemorySigner
+     * @throws InvalidMnemonicError
+     */
+    static fromMnemonic({ mnemonic, password = '', derivationPath = "44'/1729'/0'/0'", curve = 'ed25519', }) {
+        // check if curve is defined if not default tz1
+        if (!bip39.validateMnemonic(mnemonic, english_js_1.wordlist)) {
+            // avoiding exposing mnemonic again in case of mistake making invalid
+            throw new errors_1.InvalidMnemonicError();
+        }
+        const seed = bip39.mnemonicToSeedSync(mnemonic, password);
+        const sk = (0, helpers_1.generateSecretKey)(seed, derivationPath, curve);
+        return new InMemorySigner(sk);
+    }
+    /**
+     *
+     * @param key Encoded private key
+     * @param passphrase Passphrase to decrypt the private key if it is encrypted
+     * @throws InvalidKeyError
+     *
+     */
+    constructor(key, passphrase) {
+        _InMemorySigner_key.set(this, void 0);
+        const keyPrefixes = [
+            utils_1.PrefixV2.Ed25519EncryptedSeed,
+            utils_1.PrefixV2.Ed25519Seed,
+            utils_1.PrefixV2.Ed25519SecretKey,
+            utils_1.PrefixV2.Secp256k1EncryptedSecretKey,
+            utils_1.PrefixV2.Secp256k1SecretKey,
+            utils_1.PrefixV2.P256EncryptedSecretKey,
+            utils_1.PrefixV2.P256SecretKey,
+            utils_1.PrefixV2.BLS12_381EncryptedSecretKey,
+            utils_1.PrefixV2.BLS12_381SecretKey,
+        ];
+        const pre = (() => {
+            try {
+                const [, pre] = (0, utils_1.b58DecodeAndCheckPrefix)(key, keyPrefixes);
+                return pre;
+            }
+            catch {
+                throw new core_1.InvalidKeyError(`Invalid private key, expecting one of the following prefixes '${keyPrefixes}'.`);
+            }
+        })();
+        const encrypted = pre === utils_1.PrefixV2.Ed25519EncryptedSeed ||
+            pre === utils_1.PrefixV2.Secp256k1EncryptedSecretKey ||
+            pre === utils_1.PrefixV2.P256EncryptedSecretKey ||
+            pre === utils_1.PrefixV2.BLS12_381EncryptedSecretKey;
+        let decrypt;
+        if (encrypted) {
+            if (!passphrase) {
+                throw new errors_1.InvalidPassphraseError('No passphrase provided to decrypt encrypted key');
+            }
+            decrypt = (data) => {
+                const salt = (0, typedarray_to_buffer_1.default)(data.slice(0, 8));
+                const encryptedSk = data.slice(8);
+                const encryptionKey = (0, pbkdf2_js_1.pbkdf2)(sha2_js_1.sha512, passphrase, salt, { c: 32768, dkLen: 32 });
+                // Zero nonce is safe here: Tezos encrypted key format uses a fresh random salt per
+                // encryption, producing a unique PBKDF2-derived key each time. The (key, nonce) pair
+                // never repeats, satisfying NaCl secretbox requirements. This matches octez-client.
+                // See: https://gitlab.com/tezos/tezos/-/blob/master/src/lib_signer_backends/encrypted.ml
+                const res = (0, nacl_1.openSecretBox)(new Uint8Array(encryptionKey), new Uint8Array(24), // zero nonce - uniqueness provided by per-encryption derived key
+                new Uint8Array(encryptedSk));
+                if (!res) {
+                    throw new Error("can't decrypt secret key");
+                }
+                return res;
+            };
+        }
+        switch (pre) {
+            case utils_1.PrefixV2.Ed25519EncryptedSeed:
+            case utils_1.PrefixV2.Ed25519Seed:
+            case utils_1.PrefixV2.Ed25519SecretKey:
+                __classPrivateFieldSet(this, _InMemorySigner_key, new ed_key_1.EdKey(key, decrypt), "f");
+                break;
+            case utils_1.PrefixV2.Secp256k1EncryptedSecretKey:
+            case utils_1.PrefixV2.Secp256k1SecretKey:
+            case utils_1.PrefixV2.P256EncryptedSecretKey:
+            case utils_1.PrefixV2.P256SecretKey:
+                __classPrivateFieldSet(this, _InMemorySigner_key, new ec_key_1.ECKey(key, decrypt), "f");
+                break;
+            case utils_1.PrefixV2.BLS12_381EncryptedSecretKey:
+            case utils_1.PrefixV2.BLS12_381SecretKey:
+                __classPrivateFieldSet(this, _InMemorySigner_key, new bls_key_1.BLSKey(key, decrypt), "f");
+                break;
+        }
+    }
+    /**
+     *
+     * @param message Bytes to sign
+     * @param watermark Watermark to append to the bytes
+     */
+    async sign(message, watermark) {
+        const msg = typeof message == 'string' ? (0, utils_1.hex2buf)(message) : message;
+        const watermarkMsg = watermark !== undefined ? (0, utils_1.mergebuf)(watermark, msg) : msg;
+        const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = await __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
+        return {
+            bytes: (0, utils_1.buf2hex)(msg),
+            sig: signature,
+            prefixSig: prefixedSignature,
+            sbytes: (0, utils_1.buf2hex)((0, utils_1.mergebuf)(msg, 
+            // bls only Signature_prefix ff03 ref:https://octez.tezos.com/docs/shell/p2p_api.html#signature-prefix-tag-255 & https://octez.tezos.com/docs/shell/p2p_api.html#bls-prefix-tag-3
+            (0, key_interface_1.isPOP)(__classPrivateFieldGet(this, _InMemorySigner_key, "f")) ? (0, utils_1.mergebuf)(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
+        };
+    }
+    async provePossession() {
+        if ((0, key_interface_1.isPOP)(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
+            return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
+        }
+        else {
+            throw new core_1.ProhibitedActionError('Only BLS keys can prove possession');
+        }
+    }
+    get canProvePossession() {
+        return (0, key_interface_1.isPOP)(__classPrivateFieldGet(this, _InMemorySigner_key, "f"));
+    }
+    /**
+     * @returns Encoded public key
+     */
+    publicKey() {
+        return Promise.resolve(String(__classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey()));
+    }
+    /**
+     * @returns Encoded public key hash
+     */
+    publicKeyHash() {
+        return Promise.resolve(__classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey().hash());
+    }
+    /**
+     * @returns Encoded private key
+     */
+    secretKey() {
+        return Promise.resolve(__classPrivateFieldGet(this, _InMemorySigner_key, "f").secretKey());
+    }
+}
+exports.InMemorySigner = InMemorySigner;
+_InMemorySigner_key = new WeakMap();
+function publicKeyFromString(src) {
+    const [keyData, pre] = (0, utils_1.b58DecodeAndCheckPrefix)(src, [
+        utils_1.PrefixV2.Ed25519PublicKey,
+        utils_1.PrefixV2.Secp256k1PublicKey,
+        utils_1.PrefixV2.P256PublicKey,
+        utils_1.PrefixV2.BLS12_381PublicKey,
+    ]);
+    switch (pre) {
+        case utils_1.PrefixV2.Ed25519PublicKey:
+            return new ed_key_1.EdPublicKey(keyData);
+        case utils_1.PrefixV2.Secp256k1PublicKey:
+            return new ec_key_1.ECPublicKey(keyData, 'secp256k1');
+        case utils_1.PrefixV2.P256PublicKey:
+            return new ec_key_1.ECPublicKey(keyData, 'p256');
+        case utils_1.PrefixV2.BLS12_381PublicKey:
+            return new bls_key_1.BLSPublicKey(keyData);
+    }
+}

package/dist/lib/taquito-signer/src/key-interface.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPOP = isPOP;
+function isPOP(k) {
+    return 'provePossession' in k;
+}

package/dist/lib/taquito-signer/src/taquito-signer.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPassphraseError = exports.VERSION = void 0;
+/**
+ * @packageDocumentation
+ * @module @taquito/signer
+ */
+__exportStar(require("./in-memory-signer"), exports);
+var version_1 = require("./version");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
+__exportStar(require("./derivation-tools"), exports);
+__exportStar(require("./helpers"), exports);
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "InvalidPassphraseError", { enumerable: true, get: function () { return errors_1.InvalidPassphraseError; } });

package/dist/lib/taquito-signer/src/version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+exports.VERSION = {
+    "commitHash": "fb73f1546d3dff2fbba7741ca6006680212bef16",
+    "version": "24.3.0-beta.2"
+};

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

@@ -0,0 +1,203 @@
+"use strict";
+// ref https://gitlab.com/tezos/tezos/-/blob/master/src/lib_crypto/base58.ml
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.payloadLength = exports.prefixV2 = exports.PrefixV2 = void 0;
+/**
+ * base58 name to prefix mapping
+ */
+var PrefixV2;
+(function (PrefixV2) {
+    PrefixV2["BlockHash"] = "B";
+    PrefixV2["OperationHash"] = "o";
+    PrefixV2["OperationListHash"] = "Lo";
+    PrefixV2["OperationListListHash"] = "LLo";
+    PrefixV2["ProtocolHash"] = "P";
+    PrefixV2["ContextHash"] = "Co";
+    PrefixV2["BlockMetadataHash"] = "bm";
+    PrefixV2["OperationMetadataHash"] = "r";
+    PrefixV2["OperationMetadataListHash"] = "Lr";
+    PrefixV2["OperationMetadataListListHash"] = "LLr";
+    PrefixV2["Ed25519PublicKeyHash"] = "tz1";
+    PrefixV2["Secp256k1PublicKeyHash"] = "tz2";
+    PrefixV2["P256PublicKeyHash"] = "tz3";
+    PrefixV2["ContractHash"] = "KT1";
+    PrefixV2["BlindedPublicKeyHash"] = "btz1";
+    PrefixV2["BLS12_381PublicKeyHash"] = "tz4";
+    PrefixV2["TXRollupAddress"] = "txr1";
+    PrefixV2["ZkRollupHash"] = "epx1";
+    PrefixV2["ScRollupHash"] = "scr1";
+    PrefixV2["SmartRollupHash"] = "sr1";
+    PrefixV2["CryptoboxPublicKeyHash"] = "id";
+    PrefixV2["Ed25519Seed"] = "edsk";
+    PrefixV2["Ed25519PublicKey"] = "edpk";
+    PrefixV2["Secp256k1SecretKey"] = "spsk";
+    PrefixV2["P256SecretKey"] = "p2sk";
+    PrefixV2["BLS12_381SecretKey"] = "BLsk";
+    PrefixV2["ValueHash"] = "vh";
+    PrefixV2["CycleNonce"] = "nce";
+    PrefixV2["ScriptExpr"] = "expr";
+    PrefixV2["InboxHash"] = "txi";
+    PrefixV2["MessageHash"] = "txm";
+    PrefixV2["CommitmentHash"] = "txc";
+    PrefixV2["MessageResultHash"] = "txmr";
+    PrefixV2["MessageResultListHash"] = "txM";
+    PrefixV2["WithdrawListHash"] = "txw";
+    PrefixV2["ScRollupStateHash"] = "scs1";
+    PrefixV2["ScRollupCommitmentHash"] = "scc1";
+    PrefixV2["SmartRollupStateHash"] = "srs1";
+    PrefixV2["SmartRollupCommitmentHash"] = "src1";
+    PrefixV2["Ed25519EncryptedSeed"] = "edesk";
+    PrefixV2["Secp256k1EncryptedSecretKey"] = "spesk";
+    PrefixV2["P256EncryptedSecretKey"] = "p2esk";
+    PrefixV2["BLS12_381EncryptedSecretKey"] = "BLesk";
+    PrefixV2["Secp256k1EncryptedScalar"] = "seesk";
+    PrefixV2["Secp256k1PublicKey"] = "sppk";
+    PrefixV2["P256PublicKey"] = "p2pk";
+    PrefixV2["Secp256k1Scalar"] = "SSp";
+    PrefixV2["Secp256k1Element"] = "GSp";
+    PrefixV2["Ed25519SecretKey"] = "_edsk";
+    PrefixV2["Ed25519Signature"] = "edsig";
+    PrefixV2["Secp256k1Signature"] = "spsig1";
+    PrefixV2["P256Signature"] = "p2sig";
+    PrefixV2["GenericSignature"] = "sig";
+    PrefixV2["ChainID"] = "Net";
+    PrefixV2["SaplingSpendingKey"] = "sask";
+    PrefixV2["EncryptedSaplingSpendingKey"] = "_sask";
+    PrefixV2["SaplingAddress"] = "zet1";
+    PrefixV2["GenericAggregateSignature"] = "asig";
+    PrefixV2["BLS12_381Signature"] = "BLsig";
+    PrefixV2["BLS12_381PublicKey"] = "BLpk";
+    PrefixV2["SlotHeader"] = "sh";
+})(PrefixV2 || (exports.PrefixV2 = PrefixV2 = {}));
+/**
+ * base58 prefix to bytes mapping
+ */
+exports.prefixV2 = {
+    [PrefixV2.BlockHash]: new Uint8Array([1, 52]),
+    [PrefixV2.OperationHash]: new Uint8Array([5, 116]),
+    [PrefixV2.OperationListHash]: new Uint8Array([133, 233]),
+    [PrefixV2.OperationListListHash]: new Uint8Array([29, 159, 109]),
+    [PrefixV2.ProtocolHash]: new Uint8Array([2, 170]),
+    [PrefixV2.ContextHash]: new Uint8Array([79, 199]),
+    [PrefixV2.BlockMetadataHash]: new Uint8Array([234, 249]),
+    [PrefixV2.OperationMetadataHash]: new Uint8Array([5, 183]),
+    [PrefixV2.OperationMetadataListHash]: new Uint8Array([134, 39]),
+    [PrefixV2.OperationMetadataListListHash]: new Uint8Array([29, 159, 182]),
+    [PrefixV2.Ed25519PublicKeyHash]: new Uint8Array([6, 161, 159]),
+    [PrefixV2.Secp256k1PublicKeyHash]: new Uint8Array([6, 161, 161]),
+    [PrefixV2.P256PublicKeyHash]: new Uint8Array([6, 161, 164]),
+    [PrefixV2.ContractHash]: new Uint8Array([2, 90, 121]),
+    [PrefixV2.BlindedPublicKeyHash]: new Uint8Array([1, 2, 49, 223]),
+    [PrefixV2.BLS12_381PublicKeyHash]: new Uint8Array([6, 161, 166]),
+    [PrefixV2.TXRollupAddress]: new Uint8Array([1, 128, 120, 31]),
+    [PrefixV2.ZkRollupHash]: new Uint8Array([1, 23, 224, 125]),
+    [PrefixV2.ScRollupHash]: new Uint8Array([1, 118, 132, 217]),
+    [PrefixV2.SmartRollupHash]: new Uint8Array([6, 124, 117]),
+    [PrefixV2.CryptoboxPublicKeyHash]: new Uint8Array([153, 103]),
+    [PrefixV2.Ed25519Seed]: new Uint8Array([13, 15, 58, 7]),
+    [PrefixV2.Ed25519PublicKey]: new Uint8Array([13, 15, 37, 217]),
+    [PrefixV2.Secp256k1SecretKey]: new Uint8Array([17, 162, 224, 201]),
+    [PrefixV2.P256SecretKey]: new Uint8Array([16, 81, 238, 189]),
+    [PrefixV2.BLS12_381SecretKey]: new Uint8Array([3, 150, 192, 40]),
+    [PrefixV2.ValueHash]: new Uint8Array([1, 106, 242]),
+    [PrefixV2.CycleNonce]: new Uint8Array([69, 220, 169]),
+    [PrefixV2.ScriptExpr]: new Uint8Array([13, 44, 64, 27]),
+    [PrefixV2.InboxHash]: new Uint8Array([79, 148, 196]),
+    [PrefixV2.MessageHash]: new Uint8Array([79, 149, 30]),
+    [PrefixV2.CommitmentHash]: new Uint8Array([79, 148, 17]),
+    [PrefixV2.MessageResultHash]: new Uint8Array([18, 7, 206, 87]),
+    [PrefixV2.MessageResultListHash]: new Uint8Array([79, 146, 82]),
+    [PrefixV2.WithdrawListHash]: new Uint8Array([79, 150, 72]),
+    [PrefixV2.ScRollupStateHash]: new Uint8Array([17, 144, 122, 202]),
+    [PrefixV2.ScRollupCommitmentHash]: new Uint8Array([17, 144, 21, 100]),
+    [PrefixV2.SmartRollupStateHash]: new Uint8Array([17, 165, 235, 240]),
+    [PrefixV2.SmartRollupCommitmentHash]: new Uint8Array([17, 165, 134, 138]),
+    [PrefixV2.Ed25519EncryptedSeed]: new Uint8Array([7, 90, 60, 179, 41]),
+    [PrefixV2.Secp256k1EncryptedSecretKey]: new Uint8Array([9, 237, 241, 174, 150]),
+    [PrefixV2.P256EncryptedSecretKey]: new Uint8Array([9, 48, 57, 115, 171]),
+    [PrefixV2.BLS12_381EncryptedSecretKey]: new Uint8Array([2, 5, 30, 53, 25]),
+    [PrefixV2.Secp256k1EncryptedScalar]: new Uint8Array([1, 131, 36, 86, 248]),
+    [PrefixV2.Secp256k1PublicKey]: new Uint8Array([3, 254, 226, 86]),
+    [PrefixV2.P256PublicKey]: new Uint8Array([3, 178, 139, 127]),
+    [PrefixV2.Secp256k1Scalar]: new Uint8Array([38, 248, 136]),
+    [PrefixV2.Secp256k1Element]: new Uint8Array([5, 92, 0]),
+    [PrefixV2.Ed25519SecretKey]: new Uint8Array([43, 246, 78, 7]),
+    [PrefixV2.Ed25519Signature]: new Uint8Array([9, 245, 205, 134, 18]),
+    [PrefixV2.Secp256k1Signature]: new Uint8Array([13, 115, 101, 19, 63]),
+    [PrefixV2.P256Signature]: new Uint8Array([54, 240, 44, 52]),
+    [PrefixV2.GenericSignature]: new Uint8Array([4, 130, 43]),
+    [PrefixV2.ChainID]: new Uint8Array([87, 82, 0]),
+    [PrefixV2.SaplingSpendingKey]: new Uint8Array([11, 237, 20, 92]),
+    [PrefixV2.EncryptedSaplingSpendingKey]: new Uint8Array([11, 237, 20, 92]),
+    [PrefixV2.SaplingAddress]: new Uint8Array([18, 71, 40, 223]),
+    [PrefixV2.GenericAggregateSignature]: new Uint8Array([2, 75, 234, 101]),
+    [PrefixV2.BLS12_381Signature]: new Uint8Array([40, 171, 64, 207]),
+    [PrefixV2.BLS12_381PublicKey]: new Uint8Array([6, 149, 135, 204]),
+    [PrefixV2.SlotHeader]: new Uint8Array([2, 116, 180]),
+};
+/**
+ * base58 prefix to payload length mapping
+ */
+exports.payloadLength = {
+    [PrefixV2.BlockHash]: 32,
+    [PrefixV2.OperationHash]: 32,
+    [PrefixV2.OperationListHash]: 32,
+    [PrefixV2.OperationListListHash]: 32,
+    [PrefixV2.ProtocolHash]: 32,
+    [PrefixV2.ContextHash]: 32,
+    [PrefixV2.BlockMetadataHash]: 32,
+    [PrefixV2.OperationMetadataHash]: 32,
+    [PrefixV2.OperationMetadataListHash]: 32,
+    [PrefixV2.OperationMetadataListListHash]: 32,
+    [PrefixV2.Ed25519PublicKeyHash]: 20,
+    [PrefixV2.Secp256k1PublicKeyHash]: 20,
+    [PrefixV2.P256PublicKeyHash]: 20,
+    [PrefixV2.ContractHash]: 20,
+    [PrefixV2.BlindedPublicKeyHash]: 20,
+    [PrefixV2.BLS12_381PublicKeyHash]: 20,
+    [PrefixV2.TXRollupAddress]: 20,
+    [PrefixV2.ZkRollupHash]: 20,
+    [PrefixV2.ScRollupHash]: 20,
+    [PrefixV2.SmartRollupHash]: 20,
+    [PrefixV2.CryptoboxPublicKeyHash]: 16,
+    [PrefixV2.Ed25519Seed]: 32,
+    [PrefixV2.Ed25519PublicKey]: 32,
+    [PrefixV2.Secp256k1SecretKey]: 32,
+    [PrefixV2.P256SecretKey]: 32,
+    [PrefixV2.BLS12_381SecretKey]: 32,
+    [PrefixV2.ValueHash]: 32,
+    [PrefixV2.CycleNonce]: 32,
+    [PrefixV2.ScriptExpr]: 32,
+    [PrefixV2.InboxHash]: 32,
+    [PrefixV2.MessageHash]: 32,
+    [PrefixV2.CommitmentHash]: 32,
+    [PrefixV2.MessageResultHash]: 32,
+    [PrefixV2.MessageResultListHash]: 32,
+    [PrefixV2.WithdrawListHash]: 32,
+    [PrefixV2.ScRollupStateHash]: 32,
+    [PrefixV2.ScRollupCommitmentHash]: 32,
+    [PrefixV2.SmartRollupStateHash]: 32,
+    [PrefixV2.SmartRollupCommitmentHash]: 32,
+    [PrefixV2.Ed25519EncryptedSeed]: 56,
+    [PrefixV2.Secp256k1EncryptedSecretKey]: 56,
+    [PrefixV2.P256EncryptedSecretKey]: 56,
+    [PrefixV2.BLS12_381EncryptedSecretKey]: 56,
+    [PrefixV2.Secp256k1EncryptedScalar]: 60,
+    [PrefixV2.Secp256k1PublicKey]: 33,
+    [PrefixV2.P256PublicKey]: 33,
+    [PrefixV2.Secp256k1Scalar]: 33,
+    [PrefixV2.Secp256k1Element]: 33,
+    [PrefixV2.Ed25519SecretKey]: 64,
+    [PrefixV2.Ed25519Signature]: 64,
+    [PrefixV2.Secp256k1Signature]: 64,
+    [PrefixV2.P256Signature]: 64,
+    [PrefixV2.GenericSignature]: 64,
+    [PrefixV2.ChainID]: 4,
+    [PrefixV2.SaplingSpendingKey]: 169,
+    [PrefixV2.EncryptedSaplingSpendingKey]: 193,
+    [PrefixV2.SaplingAddress]: 43,
+    [PrefixV2.GenericAggregateSignature]: 96,
+    [PrefixV2.BLS12_381Signature]: 96,
+    [PrefixV2.BLS12_381PublicKey]: 48,
+    [PrefixV2.SlotHeader]: 48,
+};