@taquito/sapling 23.0.0-beta.0 → 23.0.0-beta.1

package/dist/lib/sapling-keys/helpers.js

@@ -6,13 +6,28 @@ const typedarray_to_buffer_1 = require("typedarray-to-buffer");
 const nacl_1 = require("@stablelib/nacl");
 const pbkdf2_1 = require("pbkdf2");
 const utils_1 = require("@taquito/utils");
+const core_1 = require("@taquito/core");
 function decryptKey(spendingKey, password) {
-    const keyArr = (0, utils_1.b58cdecode)(spendingKey, utils_1.prefix[utils_1.Prefix.SASK]);
-    // exit first if no password and key is encrypted
-    if (!password && spendingKey.slice(0, 4) !== 'sask') {
-        throw new errors_1.InvalidSpendingKey(spendingKey, 'no password provided to decrypt');
-    }
-    if (password && spendingKey.slice(0, 4) !== 'sask') {
+    const [keyArr, pre] = (() => {
+        try {
+            return (0, utils_1.b58DecodeAndCheckPrefix)(spendingKey, [
+                utils_1.PrefixV2.SaplingSpendingKey,
+                utils_1.PrefixV2.EncryptedSaplingSpendingKey,
+            ]);
+        }
+        catch (err) {
+            if (err instanceof core_1.ParameterValidationError) {
+                throw new errors_1.InvalidSpendingKey(spendingKey, 'invalid spending key');
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    if (pre === utils_1.PrefixV2.EncryptedSaplingSpendingKey) {
+        if (!password) {
+            throw new errors_1.InvalidSpendingKey(spendingKey, 'no password provided to decrypt');
+        }
         const salt = (0, typedarray_to_buffer_1.default)(keyArr.slice(0, 8));
         const encryptedSk = (0, typedarray_to_buffer_1.default)(keyArr.slice(8));
         const encryptionKey = pbkdf2_1.default.pbkdf2Sync(password, salt, 32768, 32, 'sha512');

package/dist/lib/sapling-keys/in-memory-spending-key.js

@@ -58,7 +58,7 @@ class InMemorySpendingKey {
             // reduce seed bytes must be 32 bytes reflecting both halves
             const seed = Buffer.from(first32.map((byte, index) => byte ^ second32[index]));
             const spendingKeyArr = new Uint8Array(yield sapling.getExtendedSpendingKey(seed, derivationPath));
-            const spendingKey = (0, utils_1.b58cencode)(spendingKeyArr, utils_1.prefix[utils_1.Prefix.SASK]);
+            const spendingKey = (0, utils_1.b58Encode)(spendingKeyArr, utils_1.PrefixV2.SaplingSpendingKey);
             return new InMemorySpendingKey(spendingKey);
         });
     }

package/dist/lib/sapling-keys/in-memory-viewing-key.js

@@ -88,7 +88,7 @@ class InMemoryViewingKey {
         return __awaiter(this, void 0, void 0, function* () {
             const { index, raw } = yield sapling.getPaymentAddressFromViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"), addressIndex);
             return {
-                address: (0, utils_1.b58cencode)(raw, utils_1.prefix[utils_1.Prefix.ZET1]),
+                address: (0, utils_1.b58Encode)(raw, utils_1.PrefixV2.SaplingAddress),
                 addressIndex: index.readInt32LE(),
             };
         });

package/dist/lib/sapling-tx-builder/sapling-transactions-builder.js

@@ -60,9 +60,12 @@ class SaplingTransactionBuilder {
                 const outputs = [];
                 const inputs = [];
                 for (const i in saplingTransactionParams) {
+                    const [address] = (0, utils_1.b58DecodeAndCheckPrefix)(saplingTransactionParams[i].to, [
+                        utils_1.PrefixV2.SaplingAddress,
+                    ]);
                     outputs.push(yield this.prepareSaplingOutputDescription({
                         saplingContext,
-                        address: (0, utils_1.b58cdecode)(saplingTransactionParams[i].to, utils_1.prefix[utils_1.Prefix.ZET1]),
+                        address,
                         amount: saplingTransactionParams[i].amount,
                         memo: saplingTransactionParams[i].memo,
                         randomCommitmentTrapdoor: rcm,
@@ -97,9 +100,12 @@ class SaplingTransactionBuilder {
                 let sumAmountOutput = new bignumber_js_1.default(0);
                 for (const i in saplingTransactionParams) {
                     sumAmountOutput = sumAmountOutput.plus(new bignumber_js_1.default(saplingTransactionParams[i].amount));
+                    const [address] = (0, utils_1.b58DecodeAndCheckPrefix)(saplingTransactionParams[i].to, [
+                        utils_1.PrefixV2.SaplingAddress,
+                    ]);
                     outputs.push(yield this.prepareSaplingOutputDescription({
                         saplingContext,
-                        address: (0, utils_1.b58cdecode)(saplingTransactionParams[i].to, utils_1.prefix[utils_1.Prefix.ZET1]),
+                        address,
                         amount: saplingTransactionParams[i].amount,
                         memo: saplingTransactionParams[i].memo,
                         randomCommitmentTrapdoor,
@@ -108,9 +114,10 @@ class SaplingTransactionBuilder {
                 }
                 if (chosenInputs.sumSelectedInputs.isGreaterThan(sumAmountOutput)) {
                     const payBackAddress = (yield saplingViewer.getAddress()).address;
+                    const [address] = (0, utils_1.b58DecodeAndCheckPrefix)(payBackAddress, [utils_1.PrefixV2.SaplingAddress]);
                     const { payBackOutput, payBackAmount } = yield this.createPaybackOutput({
                         saplingContext,
-                        address: (0, utils_1.b58cdecode)(payBackAddress, utils_1.prefix[utils_1.Prefix.ZET1]),
+                        address,
                         amount: txTotalAmount.toString(),
                         memo: constants_1.DEFAULT_MEMO,
                         randomCommitmentTrapdoor: randomCommitmentTrapdoor,

package/dist/lib/sapling-tx-viewer/helpers.js

@@ -18,7 +18,7 @@ function readableFormat(saplingTransactionProperties) {
     return {
         value: convertValueToBigNumber(saplingTransactionProperties.value),
         memo: memoHexToUtf8(Buffer.from(saplingTransactionProperties.memo).toString('hex')),
-        paymentAddress: (0, utils_1.b58cencode)(saplingTransactionProperties.paymentAddress, utils_1.prefix[utils_1.Prefix.ZET1]),
+        paymentAddress: (0, utils_1.b58Encode)(saplingTransactionProperties.paymentAddress, utils_1.PrefixV2.SaplingAddress),
     };
 }
 function convertValueToBigNumber(value) {

package/dist/lib/taquito-sapling.js

@@ -217,30 +217,9 @@ class SaplingToolkit {
     }
     createBoundData(destination) {
         return __awaiter(this, void 0, void 0, function* () {
-            const pref = destination.substring(0, 3);
-            let pad;
-            switch (pref) {
-                case 'tz1': {
-                    pad = Buffer.from('00', 'hex');
-                    break;
-                }
-                case 'tz2': {
-                    pad = Buffer.from('01', 'hex');
-                    break;
-                }
-                case 'tz3': {
-                    pad = Buffer.from('02', 'hex');
-                    break;
-                }
-                default: {
-                    throw new core_1.InvalidAddressError(destination, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) +
-                        ` expecting one of the following prefix '${utils_1.Prefix.TZ1}', '${utils_1.Prefix.TZ2}' or '${utils_1.Prefix.TZ3}'.`);
-                }
-            }
-            const decodedDestination = (0, utils_1.b58cdecode)(destination, utils_1.prefix[pref]);
-            const padDestination = Buffer.concat([pad, Buffer.from(decodedDestination)]);
+            const bytes = (0, utils_1.b58DecodePublicKeyHash)(destination, 'hex');
             const packedDestination = yield __classPrivateFieldGet(this, _SaplingToolkit_packer, "f").packData({
-                data: { bytes: padDestination.toString('hex') },
+                data: { bytes },
                 type: { prim: 'bytes' },
             });
             return Buffer.from(packedDestination.packed, 'hex');
@@ -249,12 +228,15 @@ class SaplingToolkit {
     validateDestinationImplicitAddress(to) {
         const toValidation = (0, utils_1.validateKeyHash)(to);
         if (toValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidKeyHashError(to, (0, utils_1.invalidDetail)(toValidation));
+            throw new core_1.InvalidKeyHashError(to, toValidation);
         }
     }
     validateDestinationSaplingAddress(to) {
-        if (!to.startsWith(utils_1.Prefix.ZET1)) {
-            throw new core_1.InvalidAddressError(to, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix ${utils_1.Prefix.ZET1}.`);
+        try {
+            (0, utils_1.b58DecodeAndCheckPrefix)(to, [utils_1.PrefixV2.SaplingAddress]);
+        }
+        catch (_a) {
+            throw new core_1.InvalidAddressError(to, `expecting prefix ${utils_1.PrefixV2.SaplingAddress}.`);
         }
     }
     getSaplingContractId() {

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": "7af2138a9e5c5b230c4b4c726f35c2f2e67b721c",
-    "version": "23.0.0-beta.0"
+    "commitHash": "10b3de10de15ae68d47b1fca922d3129d2f79641",
+    "version": "23.0.0-beta.1"
 };

package/dist/taquito-sapling.es6.js

@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
 import { MichelCodecPacker } from '@taquito/taquito';
-import { b58cencode, prefix, Prefix, bytesToString, toHexBuf, stringToBytes, hex2buf, mergebuf, hex2Bytes, num2PaddedHex, b58cdecode, format, validateKeyHash, ValidationResult, invalidDetail } from '@taquito/utils';
+import { b58Encode, PrefixV2, bytesToString, toHexBuf, stringToBytes, hex2buf, mergebuf, hex2Bytes, num2PaddedHex, b58DecodeAndCheckPrefix, format, validateKeyHash, ValidationResult, b58DecodePublicKeyHash } from '@taquito/utils';
 import { ParameterValidationError, TaquitoError, InvalidKeyHashError, InvalidAddressError } from '@taquito/core';
 import * as sapling from '@airgap/sapling-wasm';
 import { merkleHash } from '@airgap/sapling-wasm';
@@ -154,7 +154,7 @@ function readableFormat(saplingTransactionProperties) {
     return {
         value: convertValueToBigNumber(saplingTransactionProperties.value),
         memo: memoHexToUtf8(Buffer.from(saplingTransactionProperties.memo).toString('hex')),
-        paymentAddress: b58cencode(saplingTransactionProperties.paymentAddress, prefix[Prefix.ZET1]),
+        paymentAddress: b58Encode(saplingTransactionProperties.paymentAddress, PrefixV2.SaplingAddress),
     };
 }
 function convertValueToBigNumber(value) {
@@ -747,9 +747,12 @@ class SaplingTransactionBuilder {
                 const outputs = [];
                 const inputs = [];
                 for (const i in saplingTransactionParams) {
+                    const [address] = b58DecodeAndCheckPrefix(saplingTransactionParams[i].to, [
+                        PrefixV2.SaplingAddress,
+                    ]);
                     outputs.push(yield this.prepareSaplingOutputDescription({
                         saplingContext,
-                        address: b58cdecode(saplingTransactionParams[i].to, prefix[Prefix.ZET1]),
+                        address,
                         amount: saplingTransactionParams[i].amount,
                         memo: saplingTransactionParams[i].memo,
                         randomCommitmentTrapdoor: rcm,
@@ -784,9 +787,12 @@ class SaplingTransactionBuilder {
                 let sumAmountOutput = new BigNumber(0);
                 for (const i in saplingTransactionParams) {
                     sumAmountOutput = sumAmountOutput.plus(new BigNumber(saplingTransactionParams[i].amount));
+                    const [address] = b58DecodeAndCheckPrefix(saplingTransactionParams[i].to, [
+                        PrefixV2.SaplingAddress,
+                    ]);
                     outputs.push(yield this.prepareSaplingOutputDescription({
                         saplingContext,
-                        address: b58cdecode(saplingTransactionParams[i].to, prefix[Prefix.ZET1]),
+                        address,
                         amount: saplingTransactionParams[i].amount,
                         memo: saplingTransactionParams[i].memo,
                         randomCommitmentTrapdoor,
@@ -795,9 +801,10 @@ class SaplingTransactionBuilder {
                 }
                 if (chosenInputs.sumSelectedInputs.isGreaterThan(sumAmountOutput)) {
                     const payBackAddress = (yield saplingViewer.getAddress()).address;
+                    const [address] = b58DecodeAndCheckPrefix(payBackAddress, [PrefixV2.SaplingAddress]);
                     const { payBackOutput, payBackAmount } = yield this.createPaybackOutput({
                         saplingContext,
-                        address: b58cdecode(payBackAddress, prefix[Prefix.ZET1]),
+                        address,
                         amount: txTotalAmount.toString(),
                         memo: DEFAULT_MEMO,
                         randomCommitmentTrapdoor: randomCommitmentTrapdoor,
@@ -972,12 +979,26 @@ class SaplingTransactionBuilder {
 _SaplingTransactionBuilder_inMemorySpendingKey = new WeakMap(), _SaplingTransactionBuilder_inMemoryProvingKey = new WeakMap(), _SaplingTransactionBuilder_saplingForger = new WeakMap(), _SaplingTransactionBuilder_contractAddress = new WeakMap(), _SaplingTransactionBuilder_saplingId = new WeakMap(), _SaplingTransactionBuilder_memoSize = new WeakMap(), _SaplingTransactionBuilder_readProvider = new WeakMap(), _SaplingTransactionBuilder_saplingWrapper = new WeakMap(), _SaplingTransactionBuilder_chainId = new WeakMap(), _SaplingTransactionBuilder_saplingState = new WeakMap();
 
 function decryptKey(spendingKey, password) {
-    const keyArr = b58cdecode(spendingKey, prefix[Prefix.SASK]);
-    // exit first if no password and key is encrypted
-    if (!password && spendingKey.slice(0, 4) !== 'sask') {
-        throw new InvalidSpendingKey(spendingKey, 'no password provided to decrypt');
-    }
-    if (password && spendingKey.slice(0, 4) !== 'sask') {
+    const [keyArr, pre] = (() => {
+        try {
+            return b58DecodeAndCheckPrefix(spendingKey, [
+                PrefixV2.SaplingSpendingKey,
+                PrefixV2.EncryptedSaplingSpendingKey,
+            ]);
+        }
+        catch (err) {
+            if (err instanceof ParameterValidationError) {
+                throw new InvalidSpendingKey(spendingKey, 'invalid spending key');
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    if (pre === PrefixV2.EncryptedSaplingSpendingKey) {
+        if (!password) {
+            throw new InvalidSpendingKey(spendingKey, 'no password provided to decrypt');
+        }
         const salt = toBuffer(keyArr.slice(0, 8));
         const encryptedSk = toBuffer(keyArr.slice(8));
         const encryptionKey = pbkdf2.pbkdf2Sync(password, salt, 32768, 32, 'sha512');
@@ -1024,7 +1045,7 @@ class InMemorySpendingKey {
             // reduce seed bytes must be 32 bytes reflecting both halves
             const seed = Buffer.from(first32.map((byte, index) => byte ^ second32[index]));
             const spendingKeyArr = new Uint8Array(yield sapling.getExtendedSpendingKey(seed, derivationPath));
-            const spendingKey = b58cencode(spendingKeyArr, prefix[Prefix.SASK]);
+            const spendingKey = b58Encode(spendingKeyArr, PrefixV2.SaplingSpendingKey);
             return new InMemorySpendingKey(spendingKey);
         });
     }
@@ -1167,7 +1188,7 @@ class InMemoryViewingKey {
         return __awaiter(this, void 0, void 0, function* () {
             const { index, raw } = yield sapling.getPaymentAddressFromViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"), addressIndex);
             return {
-                address: b58cencode(raw, prefix[Prefix.ZET1]),
+                address: b58Encode(raw, PrefixV2.SaplingAddress),
                 addressIndex: index.readInt32LE(),
             };
         });
@@ -1398,30 +1419,9 @@ class SaplingToolkit {
     }
     createBoundData(destination) {
         return __awaiter(this, void 0, void 0, function* () {
-            const pref = destination.substring(0, 3);
-            let pad;
-            switch (pref) {
-                case 'tz1': {
-                    pad = Buffer.from('00', 'hex');
-                    break;
-                }
-                case 'tz2': {
-                    pad = Buffer.from('01', 'hex');
-                    break;
-                }
-                case 'tz3': {
-                    pad = Buffer.from('02', 'hex');
-                    break;
-                }
-                default: {
-                    throw new InvalidAddressError(destination, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
-                        ` expecting one of the following prefix '${Prefix.TZ1}', '${Prefix.TZ2}' or '${Prefix.TZ3}'.`);
-                }
-            }
-            const decodedDestination = b58cdecode(destination, prefix[pref]);
-            const padDestination = Buffer.concat([pad, Buffer.from(decodedDestination)]);
+            const bytes = b58DecodePublicKeyHash(destination, 'hex');
             const packedDestination = yield __classPrivateFieldGet(this, _SaplingToolkit_packer, "f").packData({
-                data: { bytes: padDestination.toString('hex') },
+                data: { bytes },
                 type: { prim: 'bytes' },
             });
             return Buffer.from(packedDestination.packed, 'hex');
@@ -1430,12 +1430,15 @@ class SaplingToolkit {
     validateDestinationImplicitAddress(to) {
         const toValidation = validateKeyHash(to);
         if (toValidation !== ValidationResult.VALID) {
-            throw new InvalidKeyHashError(to, invalidDetail(toValidation));
+            throw new InvalidKeyHashError(to, toValidation);
         }
     }
     validateDestinationSaplingAddress(to) {
-        if (!to.startsWith(Prefix.ZET1)) {
-            throw new InvalidAddressError(to, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix ${Prefix.ZET1}.`);
+        try {
+            b58DecodeAndCheckPrefix(to, [PrefixV2.SaplingAddress]);
+        }
+        catch (_a) {
+            throw new InvalidAddressError(to, `expecting prefix ${PrefixV2.SaplingAddress}.`);
         }
     }
     getSaplingContractId() {

package/dist/taquito-sapling.es6.js.map

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

package/dist/taquito-sapling.umd.js

@@ -167,7 +167,7 @@
         return {
             value: convertValueToBigNumber(saplingTransactionProperties.value),
             memo: memoHexToUtf8(Buffer.from(saplingTransactionProperties.memo).toString('hex')),
-            paymentAddress: utils.b58cencode(saplingTransactionProperties.paymentAddress, utils.prefix[utils.Prefix.ZET1]),
+            paymentAddress: utils.b58Encode(saplingTransactionProperties.paymentAddress, utils.PrefixV2.SaplingAddress),
         };
     }
     function convertValueToBigNumber(value) {
@@ -760,9 +760,12 @@
                     const outputs = [];
                     const inputs = [];
                     for (const i in saplingTransactionParams) {
+                        const [address] = utils.b58DecodeAndCheckPrefix(saplingTransactionParams[i].to, [
+                            utils.PrefixV2.SaplingAddress,
+                        ]);
                         outputs.push(yield this.prepareSaplingOutputDescription({
                             saplingContext,
-                            address: utils.b58cdecode(saplingTransactionParams[i].to, utils.prefix[utils.Prefix.ZET1]),
+                            address,
                             amount: saplingTransactionParams[i].amount,
                             memo: saplingTransactionParams[i].memo,
                             randomCommitmentTrapdoor: rcm,
@@ -797,9 +800,12 @@
                     let sumAmountOutput = new BigNumber(0);
                     for (const i in saplingTransactionParams) {
                         sumAmountOutput = sumAmountOutput.plus(new BigNumber(saplingTransactionParams[i].amount));
+                        const [address] = utils.b58DecodeAndCheckPrefix(saplingTransactionParams[i].to, [
+                            utils.PrefixV2.SaplingAddress,
+                        ]);
                         outputs.push(yield this.prepareSaplingOutputDescription({
                             saplingContext,
-                            address: utils.b58cdecode(saplingTransactionParams[i].to, utils.prefix[utils.Prefix.ZET1]),
+                            address,
                             amount: saplingTransactionParams[i].amount,
                             memo: saplingTransactionParams[i].memo,
                             randomCommitmentTrapdoor,
@@ -808,9 +814,10 @@
                     }
                     if (chosenInputs.sumSelectedInputs.isGreaterThan(sumAmountOutput)) {
                         const payBackAddress = (yield saplingViewer.getAddress()).address;
+                        const [address] = utils.b58DecodeAndCheckPrefix(payBackAddress, [utils.PrefixV2.SaplingAddress]);
                         const { payBackOutput, payBackAmount } = yield this.createPaybackOutput({
                             saplingContext,
-                            address: utils.b58cdecode(payBackAddress, utils.prefix[utils.Prefix.ZET1]),
+                            address,
                             amount: txTotalAmount.toString(),
                             memo: DEFAULT_MEMO,
                             randomCommitmentTrapdoor: randomCommitmentTrapdoor,
@@ -985,12 +992,26 @@
     _SaplingTransactionBuilder_inMemorySpendingKey = new WeakMap(), _SaplingTransactionBuilder_inMemoryProvingKey = new WeakMap(), _SaplingTransactionBuilder_saplingForger = new WeakMap(), _SaplingTransactionBuilder_contractAddress = new WeakMap(), _SaplingTransactionBuilder_saplingId = new WeakMap(), _SaplingTransactionBuilder_memoSize = new WeakMap(), _SaplingTransactionBuilder_readProvider = new WeakMap(), _SaplingTransactionBuilder_saplingWrapper = new WeakMap(), _SaplingTransactionBuilder_chainId = new WeakMap(), _SaplingTransactionBuilder_saplingState = new WeakMap();
 
     function decryptKey(spendingKey, password) {
-        const keyArr = utils.b58cdecode(spendingKey, utils.prefix[utils.Prefix.SASK]);
-        // exit first if no password and key is encrypted
-        if (!password && spendingKey.slice(0, 4) !== 'sask') {
-            throw new InvalidSpendingKey(spendingKey, 'no password provided to decrypt');
-        }
-        if (password && spendingKey.slice(0, 4) !== 'sask') {
+        const [keyArr, pre] = (() => {
+            try {
+                return utils.b58DecodeAndCheckPrefix(spendingKey, [
+                    utils.PrefixV2.SaplingSpendingKey,
+                    utils.PrefixV2.EncryptedSaplingSpendingKey,
+                ]);
+            }
+            catch (err) {
+                if (err instanceof core.ParameterValidationError) {
+                    throw new InvalidSpendingKey(spendingKey, 'invalid spending key');
+                }
+                else {
+                    throw err;
+                }
+            }
+        })();
+        if (pre === utils.PrefixV2.EncryptedSaplingSpendingKey) {
+            if (!password) {
+                throw new InvalidSpendingKey(spendingKey, 'no password provided to decrypt');
+            }
             const salt = toBuffer(keyArr.slice(0, 8));
             const encryptedSk = toBuffer(keyArr.slice(8));
             const encryptionKey = pbkdf2.pbkdf2Sync(password, salt, 32768, 32, 'sha512');
@@ -1037,7 +1058,7 @@
                 // reduce seed bytes must be 32 bytes reflecting both halves
                 const seed = Buffer.from(first32.map((byte, index) => byte ^ second32[index]));
                 const spendingKeyArr = new Uint8Array(yield sapling__namespace.getExtendedSpendingKey(seed, derivationPath));
-                const spendingKey = utils.b58cencode(spendingKeyArr, utils.prefix[utils.Prefix.SASK]);
+                const spendingKey = utils.b58Encode(spendingKeyArr, utils.PrefixV2.SaplingSpendingKey);
                 return new InMemorySpendingKey(spendingKey);
             });
         }
@@ -1180,7 +1201,7 @@
             return __awaiter(this, void 0, void 0, function* () {
                 const { index, raw } = yield sapling__namespace.getPaymentAddressFromViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"), addressIndex);
                 return {
-                    address: utils.b58cencode(raw, utils.prefix[utils.Prefix.ZET1]),
+                    address: utils.b58Encode(raw, utils.PrefixV2.SaplingAddress),
                     addressIndex: index.readInt32LE(),
                 };
             });
@@ -1411,30 +1432,9 @@
         }
         createBoundData(destination) {
             return __awaiter(this, void 0, void 0, function* () {
-                const pref = destination.substring(0, 3);
-                let pad;
-                switch (pref) {
-                    case 'tz1': {
-                        pad = Buffer.from('00', 'hex');
-                        break;
-                    }
-                    case 'tz2': {
-                        pad = Buffer.from('01', 'hex');
-                        break;
-                    }
-                    case 'tz3': {
-                        pad = Buffer.from('02', 'hex');
-                        break;
-                    }
-                    default: {
-                        throw new core.InvalidAddressError(destination, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                            ` expecting one of the following prefix '${utils.Prefix.TZ1}', '${utils.Prefix.TZ2}' or '${utils.Prefix.TZ3}'.`);
-                    }
-                }
-                const decodedDestination = utils.b58cdecode(destination, utils.prefix[pref]);
-                const padDestination = Buffer.concat([pad, Buffer.from(decodedDestination)]);
+                const bytes = utils.b58DecodePublicKeyHash(destination, 'hex');
                 const packedDestination = yield __classPrivateFieldGet(this, _SaplingToolkit_packer, "f").packData({
-                    data: { bytes: padDestination.toString('hex') },
+                    data: { bytes },
                     type: { prim: 'bytes' },
                 });
                 return Buffer.from(packedDestination.packed, 'hex');
@@ -1443,12 +1443,15 @@
         validateDestinationImplicitAddress(to) {
             const toValidation = utils.validateKeyHash(to);
             if (toValidation !== utils.ValidationResult.VALID) {
-                throw new core.InvalidKeyHashError(to, utils.invalidDetail(toValidation));
+                throw new core.InvalidKeyHashError(to, toValidation);
             }
         }
         validateDestinationSaplingAddress(to) {
-            if (!to.startsWith(utils.Prefix.ZET1)) {
-                throw new core.InvalidAddressError(to, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` expecting prefix ${utils.Prefix.ZET1}.`);
+            try {
+                utils.b58DecodeAndCheckPrefix(to, [utils.PrefixV2.SaplingAddress]);
+            }
+            catch (_a) {
+                throw new core.InvalidAddressError(to, `expecting prefix ${utils.PrefixV2.SaplingAddress}.`);
             }
         }
         getSaplingContractId() {

package/dist/taquito-sapling.umd.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/sapling",
-  "version": "23.0.0-beta.0",
+  "version": "23.0.0-beta.1",
   "description": "Allows reading and preparing sapling transactions",
   "keywords": [
     "tezos",
@@ -68,10 +68,10 @@
     "@airgap/sapling-wasm": "0.0.9",
     "@stablelib/nacl": "^1.0.4",
     "@stablelib/random": "^1.0.2",
-    "@taquito/core": "^23.0.0-beta.0",
-    "@taquito/rpc": "^23.0.0-beta.0",
-    "@taquito/taquito": "^23.0.0-beta.0",
-    "@taquito/utils": "^23.0.0-beta.0",
+    "@taquito/core": "^23.0.0-beta.1",
+    "@taquito/rpc": "^23.0.0-beta.1",
+    "@taquito/taquito": "^23.0.0-beta.1",
+    "@taquito/utils": "^23.0.0-beta.1",
     "bignumber.js": "^9.1.2",
     "bip39": "3.1.0",
     "blakejs": "^1.2.1",
@@ -106,5 +106,5 @@
     "ts-node": "^10.9.2",
     "typescript": "~5.5.4"
   },
-  "gitHead": "37cc766d60407d7909fbd2d841d9dd946243d04a"
+  "gitHead": "1469d6f0d55134a4b853598a2eec48e6f71b3da3"
 }