@taquito/michelson-encoder 22.0.0 → 23.0.0-RC.0

package/dist/lib/tokens/comparable/address.js

@@ -24,7 +24,7 @@ class AddressToken extends token_1.ComparableToken {
         this.fac = fac;
     }
     ToBigMapKey(val) {
-        const decoded = (0, utils_1.b58decode)(val);
+        const decoded = (0, utils_1.b58DecodeAddress)(val);
         return {
             key: { bytes: decoded },
             type: { prim: 'bytes' },
@@ -34,6 +34,9 @@ class AddressToken extends token_1.ComparableToken {
      * @throws {@link AddressValidationError}
      */
     validate(value) {
+        if (typeof value !== 'string') {
+            throw new AddressValidationError(value, this, 'Type error');
+        }
         if ((0, utils_1.validateAddress)(value) !== utils_1.ValidationResult.VALID) {
             throw new AddressValidationError(value, this, `Address is not valid: ${JSON.stringify(value)}`);
         }
@@ -94,18 +97,20 @@ class AddressToken extends token_1.ComparableToken {
         return (0, utils_1.encodeAddress)(bytes);
     }
     compare(address1, address2) {
-        const isImplicit = (address) => {
-            return address.startsWith('tz');
-        };
-        const implicit1 = isImplicit(address1);
-        const implicit2 = isImplicit(address2);
-        if (implicit1 && !implicit2) {
-            return -1;
+        const [addr1, endpoint1] = (0, utils_1.splitAddress)(address1);
+        const [addr2, endpoint2] = (0, utils_1.splitAddress)(address2);
+        const ep1 = endpoint1 || '';
+        const ep2 = endpoint2 || '';
+        // binary type tag actually reflects the expected prefix order
+        const bytes1 = (0, utils_1.b58DecodeAddress)(addr1, 'array');
+        const bytes2 = (0, utils_1.b58DecodeAddress)(addr2, 'array');
+        const res = (0, utils_1.compareArrays)(bytes1, bytes2);
+        if (res === 0) {
+            return ep1 < ep2 ? -1 : ep1 > ep2 ? 1 : 0;
         }
-        else if (implicit2 && !implicit1) {
-            return 1;
+        else {
+            return res;
         }
-        return super.compare(address1, address2);
     }
     findAndReturnTokens(tokenToFind, tokens) {
         if (AddressToken.prim === tokenToFind) {

package/dist/lib/tokens/comparable/key_hash.js

@@ -80,6 +80,12 @@ class KeyHashToken extends token_1.ComparableToken {
             type: { prim: KeyHashToken.prim },
         };
     }
+    compare(pkh1, pkh2) {
+        // binary type tag actually reflects the expected prefix order
+        const h1 = (0, utils_1.b58DecodePublicKeyHash)(pkh1, 'array');
+        const h2 = (0, utils_1.b58DecodePublicKeyHash)(pkh2, 'array');
+        return (0, utils_1.compareArrays)(h1, h2);
+    }
     findAndReturnTokens(tokenToFind, tokens) {
         if (KeyHashToken.prim === tokenToFind) {
             tokens.push(this);

package/dist/lib/tokens/contract.js

@@ -27,6 +27,9 @@ class ContractToken extends token_1.Token {
      * @throws {@link ContractValidationError}
      */
     validate(value) {
+        if (typeof value !== 'string') {
+            throw new ContractValidationError(value, this, 'Type error');
+        }
         // tz1,tz2 and tz3 seems to be valid contract values (for Unit contract)
         if ((0, utils_1.validateAddress)(value) !== utils_1.ValidationResult.VALID) {
             throw new ContractValidationError(value, this, `Value ${JSON.stringify(value)} is not a valid contract address.`);

package/dist/lib/tokens/key.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyToken = exports.KeyValidationError = void 0;
 const token_1 = require("./token");
 const utils_1 = require("@taquito/utils");
-const publicKeyPrefixLength = 4;
+const elliptic_1 = require("elliptic");
+const ec = new elliptic_1.default.ec('p256');
 /**
  *  @category Error
  *  @description Error that indicates a failure happening when parsing encoding/executing a Key
@@ -78,30 +79,31 @@ class KeyToken extends token_1.ComparableToken {
             type: { prim: KeyToken.prim },
         };
     }
+    decompressP256PublicKey(compressedKey) {
+        const compressedArray = Array.from(compressedKey);
+        const keyPair = ec.keyFromPublic(compressedArray);
+        const publicKey = keyPair.getPublic();
+        const uncompressedArray = publicKey.encode('array', false);
+        return Buffer.concat([new Uint8Array([0x02]), new Uint8Array(uncompressedArray)]); // add back prefix 0x02
+    }
     compare(key1, key2) {
-        const keyPrefix1 = this.getPrefix(key1);
-        const keyPrefix2 = this.getPrefix(key2);
-        if (keyPrefix1 === utils_1.Prefix.EDPK && keyPrefix2 !== utils_1.Prefix.EDPK) {
-            return -1;
+        const bytes1 = (0, utils_1.b58DecodePublicKey)(key1, 'array');
+        const bytes2 = (0, utils_1.b58DecodePublicKey)(key2, 'array');
+        let array1;
+        let array2;
+        if (bytes1[0] === 0x02) {
+            array1 = this.decompressP256PublicKey(bytes1.slice(1)); // remove prefix 0x02
         }
-        else if (keyPrefix1 === utils_1.Prefix.SPPK && keyPrefix2 !== utils_1.Prefix.SPPK) {
-            return keyPrefix2 === utils_1.Prefix.EDPK ? 1 : -1;
+        else {
+            array1 = bytes1;
         }
-        else if (keyPrefix1 === utils_1.Prefix.P2PK) {
-            if (keyPrefix2 !== utils_1.Prefix.P2PK) {
-                return 1;
-            }
-            const keyBytes1 = this.getP256PublicKeyComparableBytes(key1);
-            const keyBytes2 = this.getP256PublicKeyComparableBytes(key2);
-            return Buffer.compare(keyBytes1, keyBytes2);
+        if (bytes2[0] === 0x02) {
+            array2 = this.decompressP256PublicKey(bytes2.slice(1)); // remove prefix 0x02
         }
-        return super.compare(key1, key2);
-    }
-    getPrefix(val) {
-        return val.substring(0, publicKeyPrefixLength);
-    }
-    getP256PublicKeyComparableBytes(p2pk) {
-        return (0, utils_1.b58cdecode)(p2pk, utils_1.prefix[utils_1.Prefix.P2PK]).slice(1);
+        else {
+            array2 = bytes2;
+        }
+        return (0, utils_1.compareArrays)(array1, array2);
     }
     findAndReturnTokens(tokenToFind, tokens) {
         if (KeyToken.prim === tokenToFind) {

package/dist/lib/tokens/token.js

@@ -94,10 +94,7 @@ exports.Token = Token;
 Token._fieldNumberingStrategy = 'Latest';
 class ComparableToken extends Token {
     compare(o1, o2) {
-        if (o1 === o2) {
-            return 0;
-        }
-        return o1 < o2 ? -1 : 1;
+        return o1 < o2 ? -1 : o1 > o2 ? 1 : 0;
     }
 }
 exports.ComparableToken = ComparableToken;

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": "13639ef56845fbb7e93bcbd37d3f6d0457b0872b",
+    "version": "23.0.0-RC.0"
 };

package/dist/taquito-michelson-encoder.es6.js

@@ -1,7 +1,8 @@
 import stringify from 'fast-json-stable-stringify';
 import { TaquitoError, InvalidViewParameterError } from '@taquito/core';
 import BigNumber from 'bignumber.js';
-import { b58decode, validateAddress, ValidationResult, encodeAddress, stripHexPrefix, encodeKey, validatePublicKey, Prefix, b58cdecode, prefix, encodeKeyHash, validateKeyHash, validateSignature, validateChain } from '@taquito/utils';
+import { b58DecodeAddress, validateAddress, ValidationResult, encodeAddress, splitAddress, compareArrays, stripHexPrefix, encodeKey, validatePublicKey, b58DecodePublicKey, encodeKeyHash, validateKeyHash, b58DecodePublicKeyHash, validateSignature, validateChain } from '@taquito/utils';
+import elliptic from 'elliptic';
 
 var _a$1;
 /**
@@ -289,10 +290,7 @@ class Token {
 Token._fieldNumberingStrategy = 'Latest';
 class ComparableToken extends Token {
     compare(o1, o2) {
-        if (o1 === o2) {
-            return 0;
-        }
-        return o1 < o2 ? -1 : 1;
+        return o1 < o2 ? -1 : o1 > o2 ? 1 : 0;
     }
 }
 
@@ -1100,7 +1098,7 @@ class AddressToken extends ComparableToken {
         this.fac = fac;
     }
     ToBigMapKey(val) {
-        const decoded = b58decode(val);
+        const decoded = b58DecodeAddress(val);
         return {
             key: { bytes: decoded },
             type: { prim: 'bytes' },
@@ -1110,6 +1108,9 @@ class AddressToken extends ComparableToken {
      * @throws {@link AddressValidationError}
      */
     validate(value) {
+        if (typeof value !== 'string') {
+            throw new AddressValidationError(value, this, 'Type error');
+        }
         if (validateAddress(value) !== ValidationResult.VALID) {
             throw new AddressValidationError(value, this, `Address is not valid: ${JSON.stringify(value)}`);
         }
@@ -1170,18 +1171,20 @@ class AddressToken extends ComparableToken {
         return encodeAddress(bytes);
     }
     compare(address1, address2) {
-        const isImplicit = (address) => {
-            return address.startsWith('tz');
-        };
-        const implicit1 = isImplicit(address1);
-        const implicit2 = isImplicit(address2);
-        if (implicit1 && !implicit2) {
-            return -1;
+        const [addr1, endpoint1] = splitAddress(address1);
+        const [addr2, endpoint2] = splitAddress(address2);
+        const ep1 = endpoint1 || '';
+        const ep2 = endpoint2 || '';
+        // binary type tag actually reflects the expected prefix order
+        const bytes1 = b58DecodeAddress(addr1, 'array');
+        const bytes2 = b58DecodeAddress(addr2, 'array');
+        const res = compareArrays(bytes1, bytes2);
+        if (res === 0) {
+            return ep1 < ep2 ? -1 : ep1 > ep2 ? 1 : 0;
         }
-        else if (implicit2 && !implicit1) {
-            return 1;
+        else {
+            return res;
         }
-        return super.compare(address1, address2);
     }
     findAndReturnTokens(tokenToFind, tokens) {
         if (AddressToken.prim === tokenToFind) {
@@ -1395,6 +1398,9 @@ class ContractToken extends Token {
      * @throws {@link ContractValidationError}
      */
     validate(value) {
+        if (typeof value !== 'string') {
+            throw new ContractValidationError(value, this, 'Type error');
+        }
         // tz1,tz2 and tz3 seems to be valid contract values (for Unit contract)
         if (validateAddress(value) !== ValidationResult.VALID) {
             throw new ContractValidationError(value, this, `Value ${JSON.stringify(value)} is not a valid contract address.`);
@@ -2026,7 +2032,7 @@ class UnitToken extends ComparableToken {
 }
 UnitToken.prim = 'unit';
 
-const publicKeyPrefixLength = 4;
+const ec = new elliptic.ec('p256');
 /**
  *  @category Error
  *  @description Error that indicates a failure happening when parsing encoding/executing a Key
@@ -2100,30 +2106,31 @@ class KeyToken extends ComparableToken {
             type: { prim: KeyToken.prim },
         };
     }
+    decompressP256PublicKey(compressedKey) {
+        const compressedArray = Array.from(compressedKey);
+        const keyPair = ec.keyFromPublic(compressedArray);
+        const publicKey = keyPair.getPublic();
+        const uncompressedArray = publicKey.encode('array', false);
+        return Buffer.concat([new Uint8Array([0x02]), new Uint8Array(uncompressedArray)]); // add back prefix 0x02
+    }
     compare(key1, key2) {
-        const keyPrefix1 = this.getPrefix(key1);
-        const keyPrefix2 = this.getPrefix(key2);
-        if (keyPrefix1 === Prefix.EDPK && keyPrefix2 !== Prefix.EDPK) {
-            return -1;
+        const bytes1 = b58DecodePublicKey(key1, 'array');
+        const bytes2 = b58DecodePublicKey(key2, 'array');
+        let array1;
+        let array2;
+        if (bytes1[0] === 0x02) {
+            array1 = this.decompressP256PublicKey(bytes1.slice(1)); // remove prefix 0x02
         }
-        else if (keyPrefix1 === Prefix.SPPK && keyPrefix2 !== Prefix.SPPK) {
-            return keyPrefix2 === Prefix.EDPK ? 1 : -1;
+        else {
+            array1 = bytes1;
         }
-        else if (keyPrefix1 === Prefix.P2PK) {
-            if (keyPrefix2 !== Prefix.P2PK) {
-                return 1;
-            }
-            const keyBytes1 = this.getP256PublicKeyComparableBytes(key1);
-            const keyBytes2 = this.getP256PublicKeyComparableBytes(key2);
-            return Buffer.compare(keyBytes1, keyBytes2);
+        if (bytes2[0] === 0x02) {
+            array2 = this.decompressP256PublicKey(bytes2.slice(1)); // remove prefix 0x02
         }
-        return super.compare(key1, key2);
-    }
-    getPrefix(val) {
-        return val.substring(0, publicKeyPrefixLength);
-    }
-    getP256PublicKeyComparableBytes(p2pk) {
-        return b58cdecode(p2pk, prefix[Prefix.P2PK]).slice(1);
+        else {
+            array2 = bytes2;
+        }
+        return compareArrays(array1, array2);
     }
     findAndReturnTokens(tokenToFind, tokens) {
         if (KeyToken.prim === tokenToFind) {
@@ -2210,6 +2217,12 @@ class KeyHashToken extends ComparableToken {
             type: { prim: KeyHashToken.prim },
         };
     }
+    compare(pkh1, pkh2) {
+        // binary type tag actually reflects the expected prefix order
+        const h1 = b58DecodePublicKeyHash(pkh1, 'array');
+        const h2 = b58DecodePublicKeyHash(pkh2, 'array');
+        return compareArrays(h1, h2);
+    }
     findAndReturnTokens(tokenToFind, tokens) {
         if (KeyHashToken.prim === tokenToFind) {
             tokens.push(this);
@@ -4232,8 +4245,8 @@ class EventSchema {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "6a2c52b9e48b299dfc856149c1fa3388e77180ad",
-    "version": "22.0.0"
+    "commitHash": "13639ef56845fbb7e93bcbd37d3f6d0457b0872b",
+    "version": "23.0.0-RC.0"
 };
 
 /**

package/dist/taquito-michelson-encoder.es6.js.map

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

package/dist/taquito-michelson-encoder.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fast-json-stable-stringify'), require('@taquito/core'), require('bignumber.js'), require('@taquito/utils')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'fast-json-stable-stringify', '@taquito/core', 'bignumber.js', '@taquito/utils'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoMichelsonEncoder = {}, global.stringify, global.core, global.BigNumber, global.utils));
-})(this, (function (exports, stringify, core, BigNumber, utils) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fast-json-stable-stringify'), require('@taquito/core'), require('bignumber.js'), require('@taquito/utils'), require('elliptic')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'fast-json-stable-stringify', '@taquito/core', 'bignumber.js', '@taquito/utils', 'elliptic'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoMichelsonEncoder = {}, global.stringify, global.core, global.BigNumber, global.utils, global.elliptic));
+})(this, (function (exports, stringify, core, BigNumber, utils, elliptic) { 'use strict';
 
   var _a$1;
   /**
@@ -290,10 +290,7 @@
   Token._fieldNumberingStrategy = 'Latest';
   class ComparableToken extends Token {
       compare(o1, o2) {
-          if (o1 === o2) {
-              return 0;
-          }
-          return o1 < o2 ? -1 : 1;
+          return o1 < o2 ? -1 : o1 > o2 ? 1 : 0;
       }
   }
 
@@ -1101,7 +1098,7 @@
           this.fac = fac;
       }
       ToBigMapKey(val) {
-          const decoded = utils.b58decode(val);
+          const decoded = utils.b58DecodeAddress(val);
           return {
               key: { bytes: decoded },
               type: { prim: 'bytes' },
@@ -1111,6 +1108,9 @@
        * @throws {@link AddressValidationError}
        */
       validate(value) {
+          if (typeof value !== 'string') {
+              throw new AddressValidationError(value, this, 'Type error');
+          }
           if (utils.validateAddress(value) !== utils.ValidationResult.VALID) {
               throw new AddressValidationError(value, this, `Address is not valid: ${JSON.stringify(value)}`);
           }
@@ -1171,18 +1171,20 @@
           return utils.encodeAddress(bytes);
       }
       compare(address1, address2) {
-          const isImplicit = (address) => {
-              return address.startsWith('tz');
-          };
-          const implicit1 = isImplicit(address1);
-          const implicit2 = isImplicit(address2);
-          if (implicit1 && !implicit2) {
-              return -1;
+          const [addr1, endpoint1] = utils.splitAddress(address1);
+          const [addr2, endpoint2] = utils.splitAddress(address2);
+          const ep1 = endpoint1 || '';
+          const ep2 = endpoint2 || '';
+          // binary type tag actually reflects the expected prefix order
+          const bytes1 = utils.b58DecodeAddress(addr1, 'array');
+          const bytes2 = utils.b58DecodeAddress(addr2, 'array');
+          const res = utils.compareArrays(bytes1, bytes2);
+          if (res === 0) {
+              return ep1 < ep2 ? -1 : ep1 > ep2 ? 1 : 0;
           }
-          else if (implicit2 && !implicit1) {
-              return 1;
+          else {
+              return res;
           }
-          return super.compare(address1, address2);
       }
       findAndReturnTokens(tokenToFind, tokens) {
           if (AddressToken.prim === tokenToFind) {
@@ -1396,6 +1398,9 @@
        * @throws {@link ContractValidationError}
        */
       validate(value) {
+          if (typeof value !== 'string') {
+              throw new ContractValidationError(value, this, 'Type error');
+          }
           // tz1,tz2 and tz3 seems to be valid contract values (for Unit contract)
           if (utils.validateAddress(value) !== utils.ValidationResult.VALID) {
               throw new ContractValidationError(value, this, `Value ${JSON.stringify(value)} is not a valid contract address.`);
@@ -2027,7 +2032,7 @@
   }
   UnitToken.prim = 'unit';
 
-  const publicKeyPrefixLength = 4;
+  const ec = new elliptic.ec('p256');
   /**
    *  @category Error
    *  @description Error that indicates a failure happening when parsing encoding/executing a Key
@@ -2101,30 +2106,31 @@
               type: { prim: KeyToken.prim },
           };
       }
+      decompressP256PublicKey(compressedKey) {
+          const compressedArray = Array.from(compressedKey);
+          const keyPair = ec.keyFromPublic(compressedArray);
+          const publicKey = keyPair.getPublic();
+          const uncompressedArray = publicKey.encode('array', false);
+          return Buffer.concat([new Uint8Array([0x02]), new Uint8Array(uncompressedArray)]); // add back prefix 0x02
+      }
       compare(key1, key2) {
-          const keyPrefix1 = this.getPrefix(key1);
-          const keyPrefix2 = this.getPrefix(key2);
-          if (keyPrefix1 === utils.Prefix.EDPK && keyPrefix2 !== utils.Prefix.EDPK) {
-              return -1;
+          const bytes1 = utils.b58DecodePublicKey(key1, 'array');
+          const bytes2 = utils.b58DecodePublicKey(key2, 'array');
+          let array1;
+          let array2;
+          if (bytes1[0] === 0x02) {
+              array1 = this.decompressP256PublicKey(bytes1.slice(1)); // remove prefix 0x02
           }
-          else if (keyPrefix1 === utils.Prefix.SPPK && keyPrefix2 !== utils.Prefix.SPPK) {
-              return keyPrefix2 === utils.Prefix.EDPK ? 1 : -1;
+          else {
+              array1 = bytes1;
           }
-          else if (keyPrefix1 === utils.Prefix.P2PK) {
-              if (keyPrefix2 !== utils.Prefix.P2PK) {
-                  return 1;
-              }
-              const keyBytes1 = this.getP256PublicKeyComparableBytes(key1);
-              const keyBytes2 = this.getP256PublicKeyComparableBytes(key2);
-              return Buffer.compare(keyBytes1, keyBytes2);
+          if (bytes2[0] === 0x02) {
+              array2 = this.decompressP256PublicKey(bytes2.slice(1)); // remove prefix 0x02
           }
-          return super.compare(key1, key2);
-      }
-      getPrefix(val) {
-          return val.substring(0, publicKeyPrefixLength);
-      }
-      getP256PublicKeyComparableBytes(p2pk) {
-          return utils.b58cdecode(p2pk, utils.prefix[utils.Prefix.P2PK]).slice(1);
+          else {
+              array2 = bytes2;
+          }
+          return utils.compareArrays(array1, array2);
       }
       findAndReturnTokens(tokenToFind, tokens) {
           if (KeyToken.prim === tokenToFind) {
@@ -2211,6 +2217,12 @@
               type: { prim: KeyHashToken.prim },
           };
       }
+      compare(pkh1, pkh2) {
+          // binary type tag actually reflects the expected prefix order
+          const h1 = utils.b58DecodePublicKeyHash(pkh1, 'array');
+          const h2 = utils.b58DecodePublicKeyHash(pkh2, 'array');
+          return utils.compareArrays(h1, h2);
+      }
       findAndReturnTokens(tokenToFind, tokens) {
           if (KeyHashToken.prim === tokenToFind) {
               tokens.push(this);
@@ -4233,8 +4245,8 @@
 
   // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
   const VERSION = {
-      "commitHash": "6a2c52b9e48b299dfc856149c1fa3388e77180ad",
-      "version": "22.0.0"
+      "commitHash": "13639ef56845fbb7e93bcbd37d3f6d0457b0872b",
+      "version": "23.0.0-RC.0"
   };
 
   /**

package/dist/taquito-michelson-encoder.umd.js.map

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

package/dist/types/tokens/comparable/key_hash.d.ts

@@ -27,7 +27,7 @@ export declare class KeyHashToken extends ComparableToken {
     Execute(val: {
         bytes: string;
         string: string;
-    }): string | undefined;
+    }): string;
     /**
      * @throws {@link KeyHashValidationError}
      */
@@ -55,5 +55,6 @@ export declare class KeyHashToken extends ComparableToken {
             prim: "key_hash";
         };
     };
+    compare(pkh1: string, pkh2: string): number;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

package/dist/types/tokens/key.d.ts

@@ -27,7 +27,7 @@ export declare class KeyToken extends ComparableToken {
     Execute(val: {
         bytes: string;
         string: string;
-    }): string | undefined;
+    }): string;
     /**
      * @throws {@link KeyValidationError}
      */
@@ -46,7 +46,7 @@ export declare class KeyToken extends ComparableToken {
      */
     ExtractSchema(): "key";
     generateSchema(): BaseTokenSchema;
-    ToKey(val: any): string | undefined;
+    ToKey(val: any): string;
     ToBigMapKey(val: string): {
         key: {
             string: string;
@@ -55,8 +55,7 @@ export declare class KeyToken extends ComparableToken {
             prim: "key";
         };
     };
+    decompressP256PublicKey(compressedKey: Uint8Array): Buffer;
     compare(key1: string, key2: string): number;
-    private getPrefix;
-    private getP256PublicKeyComparableBytes;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/michelson-encoder",
-  "version": "22.0.0",
+  "version": "23.0.0-RC.0",
   "description": "converts michelson data and types into convenient JS/TS objects",
   "keywords": [
     "tezos",
@@ -67,10 +67,11 @@
     ]
   },
   "dependencies": {
-    "@taquito/core": "^22.0.0",
-    "@taquito/rpc": "^22.0.0",
-    "@taquito/utils": "^22.0.0",
+    "@taquito/core": "^23.0.0-RC.0",
+    "@taquito/rpc": "^23.0.0-RC.0",
+    "@taquito/utils": "^23.0.0-RC.0",
     "bignumber.js": "^9.1.2",
+    "elliptic": "^6.6.1",
     "fast-json-stable-stringify": "^2.1.0"
   },
   "devDependencies": {
@@ -100,5 +101,5 @@
     "ts-toolbelt": "^9.6.0",
     "typescript": "~5.5.4"
   },
-  "gitHead": "134ec228acbee03b4f40b80c89d78c718557569b"
+  "gitHead": "3bdb33e97e705d1c7090dd83e1b243e6e2a4d768"
 }