@taquito/remote-signer 22.0.0 → 23.0.0-beta.1

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

@@ -16,32 +16,11 @@ exports.RemoteSigner = exports.VERSION = void 0;
  */
 const http_utils_1 = require("@taquito/http-utils");
 const utils_1 = require("@taquito/utils");
-const blake2b_1 = require("@stablelib/blake2b");
 const typedarray_to_buffer_1 = require("typedarray-to-buffer");
 const errors_1 = require("./errors");
 const core_1 = require("@taquito/core");
 var version_1 = require("./version");
 Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
-const pref = {
-    ed: {
-        pk: utils_1.prefix['edpk'],
-        sk: utils_1.prefix['edsk'],
-        pkh: utils_1.prefix.tz1,
-        sig: utils_1.prefix.edsig,
-    },
-    p2: {
-        pk: utils_1.prefix['p2pk'],
-        sk: utils_1.prefix['p2sk'],
-        pkh: utils_1.prefix.tz3,
-        sig: utils_1.prefix.p2sig,
-    },
-    sp: {
-        pk: utils_1.prefix['sppk'],
-        sk: utils_1.prefix['spsk'],
-        pkh: utils_1.prefix.tz2,
-        sig: utils_1.prefix.spsig,
-    },
-};
 class RemoteSigner {
     constructor(pkh, rootUrl, options = {}, http = new http_utils_1.HttpBackend()) {
         this.pkh = pkh;
@@ -50,7 +29,7 @@ class RemoteSigner {
         this.http = http;
         const pkhValidation = (0, utils_1.validateKeyHash)(this.pkh);
         if (pkhValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidKeyHashError(this.pkh, (0, utils_1.invalidDetail)(pkhValidation));
+            throw new core_1.InvalidKeyHashError(this.pkh, pkhValidation);
         }
     }
     publicKeyHash() {
@@ -106,13 +85,24 @@ class RemoteSigner {
                     method: 'POST',
                     headers: this.options.headers,
                 }, watermarkedBytes);
-                const pref = signature.startsWith('sig')
-                    ? signature.substring(0, 3)
-                    : signature.substring(0, 5);
-                if (!(0, utils_1.isValidPrefix)(pref)) {
-                    throw new core_1.InvalidSignatureError(signature, (0, utils_1.invalidDetail)(utils_1.ValidationResult.NO_PREFIX_MATCHED) + ` from a remote signer.`);
-                }
-                const decoded = (0, utils_1.b58cdecode)(signature, utils_1.prefix[pref]);
+                const [decoded] = (() => {
+                    try {
+                        return (0, utils_1.b58DecodeAndCheckPrefix)(signature, [
+                            utils_1.PrefixV2.GenericSignature,
+                            utils_1.PrefixV2.Secp256k1Signature,
+                            utils_1.PrefixV2.Ed25519Signature,
+                            utils_1.PrefixV2.P256Signature,
+                        ]);
+                    }
+                    catch (err) {
+                        if (err instanceof core_1.ParameterValidationError) {
+                            throw new core_1.InvalidSignatureError(signature, err.result);
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                })();
                 const pk = yield this.publicKey();
                 yield this.verifyPublicKey(pk);
                 const signatureVerified = (0, utils_1.verifySignature)(watermarkedBytes, pk, signature);
@@ -121,7 +111,7 @@ class RemoteSigner {
                 }
                 return {
                     bytes,
-                    sig: (0, utils_1.b58cencode)(decoded, utils_1.prefix.sig),
+                    sig: (0, utils_1.b58Encode)(decoded, utils_1.PrefixV2.GenericSignature),
                     prefixSig: signature,
                     sbytes: bytes + (0, utils_1.buf2hex)((0, typedarray_to_buffer_1.default)(decoded)),
                 };
@@ -144,11 +134,9 @@ class RemoteSigner {
     }
     verifyPublicKey(publicKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const curve = publicKey.substring(0, 2);
-            const _publicKey = (0, utils_1.b58cdecode)(publicKey, pref[curve].pk);
-            const publicKeyHash = (0, utils_1.b58cencode)((0, blake2b_1.hash)(_publicKey, 20), pref[curve].pkh);
-            if (publicKeyHash !== this.pkh) {
-                throw new errors_1.PublicKeyVerificationError(publicKey, publicKeyHash, this.pkh);
+            const pkh = (0, utils_1.getPkhfromPk)(publicKey);
+            if (this.pkh !== pkh) {
+                throw new errors_1.PublicKeyVerificationError(publicKey, pkh, this.pkh);
             }
         });
     }

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

package/dist/taquito-remote-signer.es6.js

@@ -1,8 +1,7 @@
 import { HttpBackend, HttpResponseError, STATUS_CODE } from '@taquito/http-utils';
-import { prefix, validateKeyHash, ValidationResult, invalidDetail, hex2buf, mergebuf, buf2hex, isValidPrefix, b58cdecode, verifySignature, b58cencode } from '@taquito/utils';
-import { hash } from '@stablelib/blake2b';
+import { validateKeyHash, ValidationResult, hex2buf, mergebuf, buf2hex, b58DecodeAndCheckPrefix, PrefixV2, verifySignature, b58Encode, getPkhfromPk } from '@taquito/utils';
 import toBuffer from 'typedarray-to-buffer';
-import { PermissionDeniedError, TaquitoError, InvalidKeyHashError, PublicKeyNotFoundError, ProhibitedActionError, InvalidSignatureError } from '@taquito/core';
+import { PermissionDeniedError, TaquitoError, InvalidKeyHashError, PublicKeyNotFoundError, ProhibitedActionError, ParameterValidationError, InvalidSignatureError } from '@taquito/core';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -95,30 +94,10 @@ class SignatureVerificationError extends TaquitoError {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "6a2c52b9e48b299dfc856149c1fa3388e77180ad",
-    "version": "22.0.0"
+    "commitHash": "10b3de10de15ae68d47b1fca922d3129d2f79641",
+    "version": "23.0.0-beta.1"
 };
 
-const pref = {
-    ed: {
-        pk: prefix['edpk'],
-        sk: prefix['edsk'],
-        pkh: prefix.tz1,
-        sig: prefix.edsig,
-    },
-    p2: {
-        pk: prefix['p2pk'],
-        sk: prefix['p2sk'],
-        pkh: prefix.tz3,
-        sig: prefix.p2sig,
-    },
-    sp: {
-        pk: prefix['sppk'],
-        sk: prefix['spsk'],
-        pkh: prefix.tz2,
-        sig: prefix.spsig,
-    },
-};
 class RemoteSigner {
     constructor(pkh, rootUrl, options = {}, http = new HttpBackend()) {
         this.pkh = pkh;
@@ -127,7 +106,7 @@ class RemoteSigner {
         this.http = http;
         const pkhValidation = validateKeyHash(this.pkh);
         if (pkhValidation !== ValidationResult.VALID) {
-            throw new InvalidKeyHashError(this.pkh, invalidDetail(pkhValidation));
+            throw new InvalidKeyHashError(this.pkh, pkhValidation);
         }
     }
     publicKeyHash() {
@@ -183,13 +162,24 @@ class RemoteSigner {
                     method: 'POST',
                     headers: this.options.headers,
                 }, watermarkedBytes);
-                const pref = signature.startsWith('sig')
-                    ? signature.substring(0, 3)
-                    : signature.substring(0, 5);
-                if (!isValidPrefix(pref)) {
-                    throw new InvalidSignatureError(signature, invalidDetail(ValidationResult.NO_PREFIX_MATCHED) + ` from a remote signer.`);
-                }
-                const decoded = b58cdecode(signature, prefix[pref]);
+                const [decoded] = (() => {
+                    try {
+                        return b58DecodeAndCheckPrefix(signature, [
+                            PrefixV2.GenericSignature,
+                            PrefixV2.Secp256k1Signature,
+                            PrefixV2.Ed25519Signature,
+                            PrefixV2.P256Signature,
+                        ]);
+                    }
+                    catch (err) {
+                        if (err instanceof ParameterValidationError) {
+                            throw new InvalidSignatureError(signature, err.result);
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                })();
                 const pk = yield this.publicKey();
                 yield this.verifyPublicKey(pk);
                 const signatureVerified = verifySignature(watermarkedBytes, pk, signature);
@@ -198,7 +188,7 @@ class RemoteSigner {
                 }
                 return {
                     bytes,
-                    sig: b58cencode(decoded, prefix.sig),
+                    sig: b58Encode(decoded, PrefixV2.GenericSignature),
                     prefixSig: signature,
                     sbytes: bytes + buf2hex(toBuffer(decoded)),
                 };
@@ -221,11 +211,9 @@ class RemoteSigner {
     }
     verifyPublicKey(publicKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const curve = publicKey.substring(0, 2);
-            const _publicKey = b58cdecode(publicKey, pref[curve].pk);
-            const publicKeyHash = b58cencode(hash(_publicKey, 20), pref[curve].pkh);
-            if (publicKeyHash !== this.pkh) {
-                throw new PublicKeyVerificationError(publicKey, publicKeyHash, this.pkh);
+            const pkh = getPkhfromPk(publicKey);
+            if (this.pkh !== pkh) {
+                throw new PublicKeyVerificationError(publicKey, pkh, this.pkh);
             }
         });
     }

package/dist/taquito-remote-signer.es6.js.map

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

package/dist/taquito-remote-signer.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@taquito/http-utils'), require('@taquito/utils'), require('@stablelib/blake2b'), require('typedarray-to-buffer'), require('@taquito/core')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@taquito/http-utils', '@taquito/utils', '@stablelib/blake2b', 'typedarray-to-buffer', '@taquito/core'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoRemoteSigner = {}, global.httpUtils, global.utils, global.blake2b, global.toBuffer, global.core));
-})(this, (function (exports, httpUtils, utils, blake2b, toBuffer, core) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@taquito/http-utils'), require('@taquito/utils'), require('typedarray-to-buffer'), require('@taquito/core')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@taquito/http-utils', '@taquito/utils', 'typedarray-to-buffer', '@taquito/core'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoRemoteSigner = {}, global.httpUtils, global.utils, global.toBuffer, global.core));
+})(this, (function (exports, httpUtils, utils, toBuffer, core) { 'use strict';
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -95,30 +95,10 @@
 
     // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
     const VERSION = {
-        "commitHash": "6a2c52b9e48b299dfc856149c1fa3388e77180ad",
-        "version": "22.0.0"
+        "commitHash": "10b3de10de15ae68d47b1fca922d3129d2f79641",
+        "version": "23.0.0-beta.1"
     };
 
-    const pref = {
-        ed: {
-            pk: utils.prefix['edpk'],
-            sk: utils.prefix['edsk'],
-            pkh: utils.prefix.tz1,
-            sig: utils.prefix.edsig,
-        },
-        p2: {
-            pk: utils.prefix['p2pk'],
-            sk: utils.prefix['p2sk'],
-            pkh: utils.prefix.tz3,
-            sig: utils.prefix.p2sig,
-        },
-        sp: {
-            pk: utils.prefix['sppk'],
-            sk: utils.prefix['spsk'],
-            pkh: utils.prefix.tz2,
-            sig: utils.prefix.spsig,
-        },
-    };
     class RemoteSigner {
         constructor(pkh, rootUrl, options = {}, http = new httpUtils.HttpBackend()) {
             this.pkh = pkh;
@@ -127,7 +107,7 @@
             this.http = http;
             const pkhValidation = utils.validateKeyHash(this.pkh);
             if (pkhValidation !== utils.ValidationResult.VALID) {
-                throw new core.InvalidKeyHashError(this.pkh, utils.invalidDetail(pkhValidation));
+                throw new core.InvalidKeyHashError(this.pkh, pkhValidation);
             }
         }
         publicKeyHash() {
@@ -183,13 +163,24 @@
                         method: 'POST',
                         headers: this.options.headers,
                     }, watermarkedBytes);
-                    const pref = signature.startsWith('sig')
-                        ? signature.substring(0, 3)
-                        : signature.substring(0, 5);
-                    if (!utils.isValidPrefix(pref)) {
-                        throw new core.InvalidSignatureError(signature, utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) + ` from a remote signer.`);
-                    }
-                    const decoded = utils.b58cdecode(signature, utils.prefix[pref]);
+                    const [decoded] = (() => {
+                        try {
+                            return utils.b58DecodeAndCheckPrefix(signature, [
+                                utils.PrefixV2.GenericSignature,
+                                utils.PrefixV2.Secp256k1Signature,
+                                utils.PrefixV2.Ed25519Signature,
+                                utils.PrefixV2.P256Signature,
+                            ]);
+                        }
+                        catch (err) {
+                            if (err instanceof core.ParameterValidationError) {
+                                throw new core.InvalidSignatureError(signature, err.result);
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    })();
                     const pk = yield this.publicKey();
                     yield this.verifyPublicKey(pk);
                     const signatureVerified = utils.verifySignature(watermarkedBytes, pk, signature);
@@ -198,7 +189,7 @@
                     }
                     return {
                         bytes,
-                        sig: utils.b58cencode(decoded, utils.prefix.sig),
+                        sig: utils.b58Encode(decoded, utils.PrefixV2.GenericSignature),
                         prefixSig: signature,
                         sbytes: bytes + utils.buf2hex(toBuffer(decoded)),
                     };
@@ -221,11 +212,9 @@
         }
         verifyPublicKey(publicKey) {
             return __awaiter(this, void 0, void 0, function* () {
-                const curve = publicKey.substring(0, 2);
-                const _publicKey = utils.b58cdecode(publicKey, pref[curve].pk);
-                const publicKeyHash = utils.b58cencode(blake2b.hash(_publicKey, 20), pref[curve].pkh);
-                if (publicKeyHash !== this.pkh) {
-                    throw new PublicKeyVerificationError(publicKey, publicKeyHash, this.pkh);
+                const pkh = utils.getPkhfromPk(publicKey);
+                if (this.pkh !== pkh) {
+                    throw new PublicKeyVerificationError(publicKey, pkh, this.pkh);
                 }
             });
         }

package/dist/taquito-remote-signer.umd.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/remote-signer",
-  "version": "22.0.0",
+  "version": "23.0.0-beta.1",
   "description": "Remote signer provider",
   "keywords": [
     "tezos",
@@ -62,10 +62,10 @@
   "dependencies": {
     "@stablelib/blake2b": "^1.0.1",
     "@stablelib/ed25519": "^1.0.3",
-    "@taquito/core": "^22.0.0",
-    "@taquito/http-utils": "^22.0.0",
-    "@taquito/taquito": "^22.0.0",
-    "@taquito/utils": "^22.0.0",
+    "@taquito/core": "^23.0.0-beta.1",
+    "@taquito/http-utils": "^23.0.0-beta.1",
+    "@taquito/taquito": "^23.0.0-beta.1",
+    "@taquito/utils": "^23.0.0-beta.1",
     "typedarray-to-buffer": "^4.0.0"
   },
   "devDependencies": {
@@ -96,5 +96,5 @@
     "ts-toolbelt": "^9.6.0",
     "typescript": "~5.5.4"
   },
-  "gitHead": "134ec228acbee03b4f40b80c89d78c718557569b"
+  "gitHead": "1469d6f0d55134a4b853598a2eec48e6f71b3da3"
 }