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

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

@@ -0,0 +1,196 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ECKey_keyPair, _ECPublicKey_key;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECPublicKey = exports.ECKey = void 0;
+const blake2_js_1 = require("@noble/hashes/blake2.js");
+const utils_1 = require("@taquito/utils");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const nist_js_1 = require("@noble/curves/nist.js");
+const errors_1 = require("./errors");
+const pref = {
+    p256: {
+        pk: utils_1.PrefixV2.P256PublicKey,
+        sk: utils_1.PrefixV2.P256SecretKey,
+        pkh: utils_1.PrefixV2.P256PublicKeyHash,
+        sig: utils_1.PrefixV2.P256Signature,
+        tag: 2,
+    },
+    secp256k1: {
+        pk: utils_1.PrefixV2.Secp256k1PublicKey,
+        sk: utils_1.PrefixV2.Secp256k1SecretKey,
+        pkh: utils_1.PrefixV2.Secp256k1PublicKeyHash,
+        sig: utils_1.PrefixV2.Secp256k1Signature,
+        tag: 1,
+    },
+};
+/**
+ * Provide signing logic for elliptic curve based key (tz2, tz3)
+ */
+class ECKey {
+    /**
+     *
+     * @param key Encoded private key
+     * @param decrypt Decrypt function
+     * @throws InvalidKeyError
+     */
+    constructor(key, decrypt) {
+        _ECKey_keyPair.set(this, void 0);
+        const [keyData, prefix] = (0, utils_1.b58DecodeAndCheckPrefix)(key, [
+            utils_1.PrefixV2.Secp256k1EncryptedSecretKey,
+            utils_1.PrefixV2.P256EncryptedSecretKey,
+            utils_1.PrefixV2.Secp256k1SecretKey,
+            utils_1.PrefixV2.P256SecretKey,
+        ]);
+        const [decKey, curve] = (() => {
+            switch (prefix) {
+                case utils_1.PrefixV2.Secp256k1EncryptedSecretKey:
+                case utils_1.PrefixV2.P256EncryptedSecretKey:
+                    if (decrypt === undefined) {
+                        throw new Error('decryption function is not provided');
+                    }
+                    else {
+                        return [
+                            decrypt(keyData),
+                            prefix === utils_1.PrefixV2.Secp256k1EncryptedSecretKey ? 'secp256k1' : 'p256',
+                        ];
+                    }
+                case utils_1.PrefixV2.Secp256k1SecretKey:
+                    return [keyData, 'secp256k1'];
+                default:
+                    return [keyData, 'p256'];
+            }
+        })();
+        __classPrivateFieldSet(this, _ECKey_keyPair, {
+            curve,
+            secretKey: decKey,
+            publicKey: curve === 'secp256k1'
+                ? secp256k1_1.secp256k1.getPublicKey(decKey, true)
+                : nist_js_1.p256.getPublicKey(decKey, true),
+        }, "f");
+    }
+    /**
+     *
+     * @param bytes Bytes to sign
+     * @param bytesHash Blake2b hash of the bytes to sign
+     */
+    sign(bytes) {
+        const hash = (0, blake2_js_1.blake2b)(bytes, { dkLen: 32 });
+        let signature;
+        if (__classPrivateFieldGet(this, _ECKey_keyPair, "f").curve === 'secp256k1') {
+            signature = secp256k1_1.secp256k1
+                .sign(hash, __classPrivateFieldGet(this, _ECKey_keyPair, "f").secretKey, {
+                lowS: true, // Use canonical signatures (prevents malleability)
+            })
+                .toBytes('compact');
+        }
+        else {
+            signature = nist_js_1.p256
+                .sign(hash, __classPrivateFieldGet(this, _ECKey_keyPair, "f").secretKey, {
+                lowS: true, // Use canonical signatures (prevents malleability)
+            })
+                .toBytes('compact');
+        }
+        return {
+            rawSignature: signature,
+            sig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.GenericSignature),
+            prefixSig: (0, utils_1.b58Encode)(signature, pref[__classPrivateFieldGet(this, _ECKey_keyPair, "f").curve].sig),
+        };
+    }
+    /**
+     * @returns Encoded public key
+     */
+    publicKey() {
+        return new ECPublicKey(__classPrivateFieldGet(this, _ECKey_keyPair, "f").publicKey, __classPrivateFieldGet(this, _ECKey_keyPair, "f").curve);
+    }
+    /**
+     * @returns Encoded private key
+     */
+    secretKey() {
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _ECKey_keyPair, "f").secretKey, pref[__classPrivateFieldGet(this, _ECKey_keyPair, "f").curve].sk);
+    }
+}
+exports.ECKey = ECKey;
+_ECKey_keyPair = new WeakMap();
+class ECPublicKey {
+    constructor(src, curve) {
+        _ECPublicKey_key.set(this, void 0);
+        const [key, crv] = (() => {
+            if (typeof src === 'string') {
+                const [key, pre] = (0, utils_1.b58DecodeAndCheckPrefix)(src, [
+                    utils_1.PrefixV2.Secp256k1PublicKey,
+                    utils_1.PrefixV2.P256PublicKey,
+                ]);
+                return [key, pre === utils_1.PrefixV2.Secp256k1PublicKey ? 'secp256k1' : 'p256'];
+            }
+            else if (curve !== undefined) {
+                return [src, curve];
+            }
+            else {
+                throw new errors_1.InvalidCurveError('missing curve type');
+            }
+        })();
+        // For ECPublicKey, we don't need the private key, so we pass an empty array
+        // The public key is stored separately
+        __classPrivateFieldSet(this, _ECPublicKey_key, key, "f");
+        this.curve = crv;
+    }
+    compare(other) {
+        if (other instanceof ECPublicKey) {
+            if (this.curve === other.curve) {
+                const compress = this.curve === 'secp256k1';
+                return (0, utils_1.compareArrays)(this.bytes(compress), other.bytes(compress));
+            }
+            else if (this.curve === 'secp256k1') {
+                return -1;
+            }
+            else {
+                return 1;
+            }
+        }
+        else {
+            throw new utils_1.InvalidPublicKeyError('ECDSA key expected');
+        }
+    }
+    hash() {
+        const key = this.bytes();
+        return (0, utils_1.b58Encode)((0, blake2_js_1.blake2b)(key, { dkLen: 20 }), pref[this.curve].pkh);
+    }
+    bytes(compress = true) {
+        // @noble/curves supports both compressed and uncompressed formats
+        // We need to convert the stored public key to the requested format
+        if (this.curve === 'secp256k1') {
+            // For secp256k1, we need to get the public key from the stored bytes and convert format
+            const point = secp256k1_1.secp256k1.Point.fromHex(__classPrivateFieldGet(this, _ECPublicKey_key, "f"));
+            return point.toBytes(compress);
+        }
+        else {
+            // For p256, we need to get the public key from the stored bytes and convert format
+            const point = nist_js_1.p256.Point.fromHex(__classPrivateFieldGet(this, _ECPublicKey_key, "f"));
+            return point.toBytes(compress);
+        }
+    }
+    toProtocol() {
+        const key = this.bytes();
+        const res = new Uint8Array(key.length + 1);
+        res[0] = pref[this.curve].tag;
+        res.set(key, 1);
+        return res;
+    }
+    toString() {
+        const key = this.bytes();
+        return (0, utils_1.b58Encode)(key, pref[this.curve].pk);
+    }
+}
+exports.ECPublicKey = ECPublicKey;
+_ECPublicKey_key = new WeakMap();

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

@@ -0,0 +1,130 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EdKey_keyPair, _EdPublicKey_key;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdPublicKey = exports.EdKey = void 0;
+const blake2_js_1 = require("@noble/hashes/blake2.js");
+const ed25519_1 = require("@noble/curves/ed25519");
+const utils_1 = require("@taquito/utils");
+function generateKeyPairFromSeed(seed) {
+    const publicKey = ed25519_1.ed25519.getPublicKey(seed);
+    const secretKey = new Uint8Array(64);
+    secretKey.set(seed);
+    secretKey.set(publicKey, 32);
+    return { secretKey, publicKey };
+}
+/**
+ * Provide signing logic for ed25519 curve based key (tz1)
+ */
+class EdKey {
+    /**
+     *
+     * @param key Encoded private key
+     * @param encrypted Is the private key encrypted
+     * @param decrypt Decrypt function
+     * @throws InvalidKeyError
+     */
+    constructor(key, decrypt) {
+        _EdKey_keyPair.set(this, void 0);
+        const tmp = (0, utils_1.b58DecodeAndCheckPrefix)(key, [
+            utils_1.PrefixV2.Ed25519SecretKey,
+            utils_1.PrefixV2.Ed25519EncryptedSeed,
+            utils_1.PrefixV2.Ed25519Seed,
+        ]);
+        let [keyData] = tmp;
+        const [, prefix] = tmp;
+        if (prefix === utils_1.PrefixV2.Ed25519SecretKey) {
+            __classPrivateFieldSet(this, _EdKey_keyPair, {
+                secretKey: keyData,
+                publicKey: keyData.slice(32),
+            }, "f");
+        }
+        else {
+            if (prefix === utils_1.PrefixV2.Ed25519EncryptedSeed) {
+                if (decrypt !== undefined) {
+                    keyData = decrypt(keyData);
+                }
+                else {
+                    throw new Error('decryption function is not provided');
+                }
+            }
+            __classPrivateFieldSet(this, _EdKey_keyPair, generateKeyPairFromSeed(keyData), "f");
+        }
+    }
+    /**
+     *
+     * @param bytes Bytes to sign
+     * @param bytesHash Blake2b hash of the bytes to sign
+     */
+    sign(bytes) {
+        const hash = (0, blake2_js_1.blake2b)(bytes, { dkLen: 32 });
+        const seed = __classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey.subarray(0, 32);
+        const signature = ed25519_1.ed25519.sign(hash, seed);
+        return {
+            rawSignature: signature,
+            sig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.GenericSignature),
+            prefixSig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.Ed25519Signature),
+        };
+    }
+    /**
+     * @returns Encoded public key
+     */
+    publicKey() {
+        return new EdPublicKey(__classPrivateFieldGet(this, _EdKey_keyPair, "f").publicKey);
+    }
+    /**
+     * @returns Encoded private key
+     */
+    secretKey() {
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, utils_1.PrefixV2.Ed25519SecretKey);
+    }
+}
+exports.EdKey = EdKey;
+_EdKey_keyPair = new WeakMap();
+class EdPublicKey {
+    constructor(src) {
+        _EdPublicKey_key.set(this, void 0);
+        if (typeof src === 'string') {
+            const [key, _] = (0, utils_1.b58DecodeAndCheckPrefix)(src, [utils_1.PrefixV2.Ed25519PublicKey]);
+            __classPrivateFieldSet(this, _EdPublicKey_key, key, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _EdPublicKey_key, src, "f");
+        }
+    }
+    compare(other) {
+        if (other instanceof EdPublicKey) {
+            return (0, utils_1.compareArrays)(this.bytes(), other.bytes());
+        }
+        else {
+            throw new utils_1.InvalidPublicKeyError('EdDSA key expected');
+        }
+    }
+    hash() {
+        return (0, utils_1.b58Encode)((0, blake2_js_1.blake2b)(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), { dkLen: 20 }), utils_1.PrefixV2.Ed25519PublicKeyHash);
+    }
+    bytes() {
+        return __classPrivateFieldGet(this, _EdPublicKey_key, "f");
+    }
+    toProtocol() {
+        const res = new Uint8Array(__classPrivateFieldGet(this, _EdPublicKey_key, "f").length + 1);
+        res[0] = 0;
+        res.set(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), 1);
+        return res;
+    }
+    toString() {
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), utils_1.PrefixV2.Ed25519PublicKey);
+    }
+}
+exports.EdPublicKey = EdPublicKey;
+_EdPublicKey_key = new WeakMap();

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPassphraseError = exports.ToBeImplemented = exports.InvalidSeedLengthError = exports.InvalidCurveError = exports.InvalidBitSize = exports.InvalidMnemonicError = void 0;
+const core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates an invalid Mnemonic being passed or used
+ */
+class InvalidMnemonicError extends core_1.ParameterValidationError {
+    constructor(_mnemonic) {
+        super();
+        this.name = 'InvalidMnemonicError';
+        this.message = 'Invalid mnemonic';
+    }
+}
+exports.InvalidMnemonicError = InvalidMnemonicError;
+/**
+ *  @category Error
+ *  Error that indicates a curve with incorrect bit size being passed or used
+ */
+class InvalidBitSize extends core_1.ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'InvalidBitSize';
+    }
+}
+exports.InvalidBitSize = InvalidBitSize;
+/**
+ *  @category Error
+ *  Error that indicates an unsupported cureve being passed or used
+ */
+class InvalidCurveError extends core_1.ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'InvalidCurveError';
+    }
+}
+exports.InvalidCurveError = InvalidCurveError;
+/**
+ *  @category Error
+ *  Error that indicates a seed with invalid length being passed or used
+ */
+class InvalidSeedLengthError extends core_1.ParameterValidationError {
+    constructor(seedLength) {
+        super();
+        this.seedLength = seedLength;
+        this.name = 'InvalidSeedLengthError';
+        this.message = `Invalid seed length "${seedLength}" expecting length between 16 to 64.`;
+    }
+}
+exports.InvalidSeedLengthError = InvalidSeedLengthError;
+/**
+ *  @category Error
+ *  Error that indicates a feature still under developement
+ */
+class ToBeImplemented extends core_1.UnsupportedActionError {
+    constructor() {
+        super();
+        this.name = 'ToBeImplemented';
+        this.message = 'This feature is under developement';
+    }
+}
+exports.ToBeImplemented = ToBeImplemented;
+/**
+ *  @category Error
+ *  Error that indicates an invalid passphrase being passed or used
+ */
+class InvalidPassphraseError extends core_1.ParameterValidationError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'InvalidPassphraseError';
+    }
+}
+exports.InvalidPassphraseError = InvalidPassphraseError;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSecretKey = void 0;
+const utils_1 = require("@taquito/utils");
+const ed25519_1 = require("./derivation-tools/ed25519");
+const ecdsa_1 = require("./derivation-tools/ecdsa");
+const derivation_tools_1 = require("./derivation-tools");
+const errors_1 = require("./errors");
+// bip32 when supported add to @param curve bip25519
+/**
+ *
+ * @param seed bip39.mnemonicToSeed
+ * @param derivationPath Tezos Requirement 44'/1729' for HD key address default 44'/1729'/0'/0'
+ * @param curve 'ed25519' | 'secp256k1' | 'p256''
+ * @returns final Derivation of HD keys tezos Secret key
+ * @throws InvalidCurveError | ToBeImplemented
+ */
+const generateSecretKey = (seed, derivationPath, curve) => {
+    const path = derivation_tools_1.Path.fromString(derivationPath);
+    let node;
+    switch (curve) {
+        case 'ed25519': {
+            node = ed25519_1.PrivateKey.fromSeed(seed).derivePath(path);
+            const sk = (0, utils_1.b58Encode)(node.seed().slice(0, 32), utils_1.PrefixV2.Ed25519Seed);
+            return sk;
+        }
+        case 'secp256k1':
+        case 'p256': {
+            const prefixType = curve === 'secp256k1' ? utils_1.PrefixV2.Secp256k1SecretKey : utils_1.PrefixV2.P256SecretKey;
+            let privKey = ecdsa_1.PrivateKey.fromSeed(seed, curve);
+            privKey = privKey.derivePath(path);
+            const uint8arr = new Uint8Array(privKey.keyPair.secretKey.toArray());
+            const sk = (0, utils_1.b58Encode)(uint8arr, prefixType);
+            return sk;
+        }
+        case 'bip25519': {
+            throw new errors_1.ToBeImplemented();
+        }
+        default: {
+            throw new errors_1.InvalidCurveError(`Unsupported curve "${curve}" expecting one of the following "ed25519", "secp256k1", "p256"`);
+        }
+    }
+};
+exports.generateSecretKey = generateSecretKey;