@taquito/signer 24.2.0 → 24.3.0-beta.1

package/dist/taquito-signer.umd.js

@@ -40,16 +40,6 @@
     /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-
     function __classPrivateFieldGet(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");
@@ -70,7 +60,7 @@
 
     var _EdKey_keyPair, _EdPublicKey_key;
     /**
-     * @description Provide signing logic for ed25519 curve based key (tz1)
+     * Provide signing logic for ed25519 curve based key (tz1)
      */
     class EdKey {
         /**
@@ -78,7 +68,7 @@
          * @param key Encoded private key
          * @param encrypted Is the private key encrypted
          * @param decrypt Decrypt function
-         * @throws {@link InvalidKeyError}
+         * @throws InvalidKeyError
          */
         constructor(key, decrypt) {
             _EdKey_keyPair.set(this, void 0);
@@ -174,19 +164,18 @@
 
     /**
      *  @category Error
-     *  @description Error that indicates an invalid Mnemonic being passed or used
+     *  Error that indicates an invalid Mnemonic being passed or used
      */
     class InvalidMnemonicError extends core.ParameterValidationError {
-        constructor(mnemonic) {
+        constructor(_mnemonic) {
             super();
-            this.mnemonic = mnemonic;
             this.name = 'InvalidMnemonicError';
-            this.message = `Invalid mnemonic "${mnemonic}"`;
+            this.message = 'Invalid mnemonic';
         }
     }
     /**
      *  @category Error
-     *  @description Error that indicates a curve with incorrect bit size being passed or used
+     *  Error that indicates a curve with incorrect bit size being passed or used
      */
     class InvalidBitSize extends core.ParameterValidationError {
         constructor(message) {
@@ -197,7 +186,7 @@
     }
     /**
      *  @category Error
-     *  @description Error that indicates an unsupported cureve being passed or used
+     *  Error that indicates an unsupported cureve being passed or used
      */
     class InvalidCurveError extends core.ParameterValidationError {
         constructor(message) {
@@ -208,7 +197,7 @@
     }
     /**
      *  @category Error
-     *  @description Error that indicates a seed with invalid length being passed or used
+     *  Error that indicates a seed with invalid length being passed or used
      */
     class InvalidSeedLengthError extends core.ParameterValidationError {
         constructor(seedLength) {
@@ -220,7 +209,7 @@
     }
     /**
      *  @category Error
-     *  @description Error that indicates a feature still under developement
+     *  Error that indicates a feature still under developement
      */
     class ToBeImplemented extends core.UnsupportedActionError {
         constructor() {
@@ -231,7 +220,7 @@
     }
     /**
      *  @category Error
-     *  @description Error that indicates an invalid passphrase being passed or used
+     *  Error that indicates an invalid passphrase being passed or used
      */
     class InvalidPassphraseError extends core.ParameterValidationError {
         constructor(message) {
@@ -259,14 +248,14 @@
         },
     };
     /**
-     * @description Provide signing logic for elliptic curve based key (tz2, tz3)
+     * Provide signing logic for elliptic curve based key (tz2, tz3)
      */
     class ECKey {
         /**
          *
          * @param key Encoded private key
          * @param decrypt Decrypt function
-         * @throws {@link InvalidKeyError}
+         * @throws InvalidKeyError
          */
         constructor(key, decrypt) {
             _ECKey_keyPair.set(this, void 0);
@@ -452,7 +441,7 @@
          *
          * @param seedSrc result of Bip39.mnemonicToSeed
          * @returns instance of PrivateKey
-         * @throws {@link InvalidSeedLengthError}
+         * @throws InvalidSeedLengthError
          */
         static fromSeed(seedSrc) {
             const seed = typeof seedSrc === 'string' ? parseHex(seedSrc) : seedSrc;
@@ -471,7 +460,7 @@
             return this.priv.subarray(0, 32);
         }
         /**
-         * @index current derivation path item ie: 1729'
+         \* @remarks index: current derivation path item ie: 1729'
          * @returns derivation path child of original private key pair
          */
         derive(index) {
@@ -535,7 +524,7 @@
          * @param seedSrc result of Bip39.mnemonicToSeed
          * @param curve known supported curve p256 or secp256k1
          * @returns instance of PrivateKey non-HD keys derived
-         * @throws {@link InvalidBitSize} | {@link InvalidCurveError} | {@link InvalidSeedLengthError}
+         * @throws InvalidBitSize | InvalidCurveError | InvalidSeedLengthError
          */
         static fromSeed(seedSrc, curve) {
             let seed = typeof seedSrc === 'string' ? parseHex(seedSrc) : seedSrc;
@@ -629,7 +618,7 @@
         /**
          *
          * @returns Uint8Array (if contains a private key)
-         * @throws {@link InvalidKeyError}
+         * @throws InvalidKeyError
          */
         bytes() {
             if (!this.keyPair.secretKey) {
@@ -690,7 +679,7 @@
      * @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 {@link InvalidCurveError} | {@link ToBeImplemented}
+     * @throws InvalidCurveError | ToBeImplemented
      */
     const generateSecretKey = (seed, derivationPath, curve) => {
         const path = Path.fromString(derivationPath);
@@ -811,40 +800,33 @@
 
     var _InMemorySigner_key;
     /**
-     * @description A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
+     * A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
      *
-     * @warn If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
-     * @throws {@link InvalidMnemonicError}
+     * @remarks If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
+     * @throws InvalidMnemonicError
      */
     class InMemorySigner {
         static fromFundraiser(email, password, mnemonic) {
             if (!Bip39__namespace.validateMnemonic(mnemonic)) {
-                throw new InvalidMnemonicError(mnemonic);
+                throw new InvalidMnemonicError();
             }
             const seed = Bip39__namespace.mnemonicToSeedSync(mnemonic, `${email}${password}`);
             const key = utils.b58Encode(seed.subarray(0, 32), utils.PrefixV2.Ed25519Seed);
             return new InMemorySigner(key);
         }
-        static fromSecretKey(key, passphrase) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return new InMemorySigner(key, passphrase);
-            });
+        static async fromSecretKey(key, passphrase) {
+            return new InMemorySigner(key, passphrase);
         }
         /**
          *
-         * @description Instantiation of an InMemorySigner instance from a mnemonic
-         * @param mnemonic 12-24 word mnemonic
-         * @param password password used to encrypt the mnemonic to seed value
-         * @param derivationPath default 44'/1729'/0'/0' (44'/1729' mandatory)
-         * @param curve currently only supported for tz1, tz2, tz3 addresses. soon bip25519
+         * Instantiation of an InMemorySigner instance from a mnemonic
          * @returns InMemorySigner
-         * @throws {@link InvalidMnemonicError}
+         * @throws InvalidMnemonicError
          */
         static fromMnemonic({ mnemonic, password = '', derivationPath = "44'/1729'/0'/0'", curve = 'ed25519', }) {
             // check if curve is defined if not default tz1
             if (!Bip39__namespace.validateMnemonic(mnemonic)) {
-                // avoiding exposing mnemonic again in case of mistake making invalid
-                throw new InvalidMnemonicError(mnemonic);
+                throw new InvalidMnemonicError();
             }
             const seed = Bip39__namespace.mnemonicToSeedSync(mnemonic, password);
             const sk = generateSecretKey(seed, derivationPath, curve);
@@ -854,7 +836,7 @@
          *
          * @param key Encoded private key
          * @param passphrase Passphrase to decrypt the private key if it is encrypted
-         * @throws {@link InvalidKeyError}
+         * @throws InvalidKeyError
          *
          */
         constructor(key, passphrase) {
@@ -875,7 +857,7 @@
                     const [, pre] = utils.b58DecodeAndCheckPrefix(key, keyPrefixes);
                     return pre;
                 }
-                catch (_a) {
+                catch {
                     throw new core.InvalidKeyError(`Invalid private key, expecting one of the following prefixes '${keyPrefixes}'.`);
                 }
             })();
@@ -924,33 +906,29 @@
         }
         /**
          *
-         * @param bytes Bytes to sign
+         * @param message Bytes to sign
          * @param watermark Watermark to append to the bytes
          */
-        sign(message, watermark) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const msg = typeof message == 'string' ? utils.hex2buf(message) : message;
-                const watermarkMsg = watermark !== undefined ? utils.mergebuf(watermark, msg) : msg;
-                const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = yield __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
-                return {
-                    bytes: utils.buf2hex(msg),
-                    sig: signature,
-                    prefixSig: prefixedSignature,
-                    sbytes: utils.buf2hex(utils.mergebuf(msg, 
-                    // bls only Signature_prefix ff03 ref:https://octez.tezos.com/docs/shell/p2p_api.html#signature-prefix-tag-255 & https://octez.tezos.com/docs/shell/p2p_api.html#bls-prefix-tag-3
-                    isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f")) ? utils.mergebuf(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
-                };
-            });
+        async sign(message, watermark) {
+            const msg = typeof message == 'string' ? utils.hex2buf(message) : message;
+            const watermarkMsg = watermark !== undefined ? utils.mergebuf(watermark, msg) : msg;
+            const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = await __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
+            return {
+                bytes: utils.buf2hex(msg),
+                sig: signature,
+                prefixSig: prefixedSignature,
+                sbytes: utils.buf2hex(utils.mergebuf(msg, 
+                // bls only Signature_prefix ff03 ref:https://octez.tezos.com/docs/shell/p2p_api.html#signature-prefix-tag-255 & https://octez.tezos.com/docs/shell/p2p_api.html#bls-prefix-tag-3
+                isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f")) ? utils.mergebuf(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
+            };
         }
-        provePossession() {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
-                    return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
-                }
-                else {
-                    throw new core.ProhibitedActionError('Only BLS keys can prove possession');
-                }
-            });
+        async provePossession() {
+            if (isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
+                return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
+            }
+            else {
+                throw new core.ProhibitedActionError('Only BLS keys can prove possession');
+            }
         }
         get canProvePossession() {
             return isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"));
@@ -996,8 +974,8 @@
 
     // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
     const VERSION = {
-        "commitHash": "105a7b15cfb862a0732c204e0e9741098d697775",
-        "version": "24.2.0"
+        "commitHash": "05df48fee92f846cba793920d6fa829afd6a1847",
+        "version": "24.3.0-beta.1"
     };
 
     exports.ECDSA = ecdsa;

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

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

package/dist/types/derivation-tools/ecdsa.d.ts

@@ -25,7 +25,7 @@ export declare class PrivateKey implements ExtendedPrivateKey {
      * @param seedSrc result of Bip39.mnemonicToSeed
      * @param curve known supported curve p256 or secp256k1
      * @returns instance of PrivateKey non-HD keys derived
-     * @throws {@link InvalidBitSize} | {@link InvalidCurveError} | {@link InvalidSeedLengthError}
+     * @throws InvalidBitSize | InvalidCurveError | InvalidSeedLengthError
      */
     static fromSeed(seedSrc: Uint8Array | string, curve: CurveName): PrivateKey;
     /**
@@ -43,7 +43,7 @@ export declare class PrivateKey implements ExtendedPrivateKey {
     /**
      *
      * @returns Uint8Array (if contains a private key)
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     bytes(): Uint8Array;
 }

package/dist/types/derivation-tools/ed25519.d.ts

@@ -12,7 +12,7 @@ export declare class PrivateKey implements ExtendedPrivateKey {
      *
      * @param seedSrc result of Bip39.mnemonicToSeed
      * @returns instance of PrivateKey
-     * @throws {@link InvalidSeedLengthError}
+     * @throws InvalidSeedLengthError
      */
     static fromSeed(seedSrc: Uint8Array | string): PrivateKey;
     /**
@@ -21,7 +21,7 @@ export declare class PrivateKey implements ExtendedPrivateKey {
      */
     seed(): Uint8Array;
     /**
-     * @index current derivation path item ie: 1729'
+     \* @remarks index: current derivation path item ie: 1729'
      * @returns derivation path child of original private key pair
      */
     derive(index: number): PrivateKey;

package/dist/types/ec-key.d.ts

@@ -2,7 +2,7 @@ import { SigningKey, PublicKey } from './key-interface';
 import { RawSignResult } from '@taquito/core';
 type Curve = 'p256' | 'secp256k1';
 /**
- * @description Provide signing logic for elliptic curve based key (tz2, tz3)
+ * Provide signing logic for elliptic curve based key (tz2, tz3)
  */
 export declare class ECKey implements SigningKey {
     #private;
@@ -10,7 +10,7 @@ export declare class ECKey implements SigningKey {
      *
      * @param key Encoded private key
      * @param decrypt Decrypt function
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     constructor(key: string, decrypt?: (k: Uint8Array) => Uint8Array);
     /**

package/dist/types/ed-key.d.ts

@@ -1,7 +1,7 @@
 import { SigningKey, PublicKey } from './key-interface';
 import { RawSignResult } from '@taquito/core';
 /**
- * @description Provide signing logic for ed25519 curve based key (tz1)
+ * Provide signing logic for ed25519 curve based key (tz1)
  */
 export declare class EdKey implements SigningKey {
     #private;
@@ -10,7 +10,7 @@ export declare class EdKey implements SigningKey {
      * @param key Encoded private key
      * @param encrypted Is the private key encrypted
      * @param decrypt Decrypt function
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     constructor(key: string, decrypt?: (k: Uint8Array) => Uint8Array);
     /**

package/dist/types/errors.d.ts

@@ -1,15 +1,18 @@
 import { ParameterValidationError, UnsupportedActionError } from '@taquito/core';
 /**
  *  @category Error
- *  @description Error that indicates an invalid Mnemonic being passed or used
+ *  Error that indicates an invalid Mnemonic being passed or used
  */
 export declare class InvalidMnemonicError extends ParameterValidationError {
-    readonly mnemonic: string;
-    constructor(mnemonic: string);
+    /**
+     * @deprecated Use `new InvalidMnemonicError()` instead. The mnemonic argument is ignored for security reasons.
+     */
+    constructor(_mnemonic: string);
+    constructor();
 }
 /**
  *  @category Error
- *  @description Error that indicates a curve with incorrect bit size being passed or used
+ *  Error that indicates a curve with incorrect bit size being passed or used
  */
 export declare class InvalidBitSize extends ParameterValidationError {
     readonly message: string;
@@ -17,7 +20,7 @@ export declare class InvalidBitSize extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an unsupported cureve being passed or used
+ *  Error that indicates an unsupported cureve being passed or used
  */
 export declare class InvalidCurveError extends ParameterValidationError {
     readonly message: string;
@@ -25,7 +28,7 @@ export declare class InvalidCurveError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a seed with invalid length being passed or used
+ *  Error that indicates a seed with invalid length being passed or used
  */
 export declare class InvalidSeedLengthError extends ParameterValidationError {
     readonly seedLength: number;
@@ -33,14 +36,14 @@ export declare class InvalidSeedLengthError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a feature still under developement
+ *  Error that indicates a feature still under developement
  */
 export declare class ToBeImplemented extends UnsupportedActionError {
     constructor();
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid passphrase being passed or used
+ *  Error that indicates an invalid passphrase being passed or used
  */
 export declare class InvalidPassphraseError extends ParameterValidationError {
     readonly message: string;

package/dist/types/helpers.d.ts

@@ -5,6 +5,6 @@ export type Curves = 'ed25519' | 'secp256k1' | 'p256' | 'bip25519';
  * @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 {@link InvalidCurveError} | {@link ToBeImplemented}
+ * @throws InvalidCurveError | ToBeImplemented
  */
 export declare const generateSecretKey: (seed: Uint8Array, derivationPath: string, curve: Curves) => string;

package/dist/types/in-memory-signer.d.ts

@@ -8,10 +8,10 @@ export interface FromMnemonicParams {
     curve?: Curves;
 }
 /**
- * @description A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
+ * A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
  *
- * @warn If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
- * @throws {@link InvalidMnemonicError}
+ * @remarks If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
+ * @throws InvalidMnemonicError
  */
 export declare class InMemorySigner implements Signer {
     #private;
@@ -19,26 +19,22 @@ export declare class InMemorySigner implements Signer {
     static fromSecretKey(key: string, passphrase?: string): Promise<InMemorySigner>;
     /**
      *
-     * @description Instantiation of an InMemorySigner instance from a mnemonic
-     * @param mnemonic 12-24 word mnemonic
-     * @param password password used to encrypt the mnemonic to seed value
-     * @param derivationPath default 44'/1729'/0'/0' (44'/1729' mandatory)
-     * @param curve currently only supported for tz1, tz2, tz3 addresses. soon bip25519
+     * Instantiation of an InMemorySigner instance from a mnemonic
      * @returns InMemorySigner
-     * @throws {@link InvalidMnemonicError}
+     * @throws InvalidMnemonicError
      */
     static fromMnemonic({ mnemonic, password, derivationPath, curve, }: FromMnemonicParams): InMemorySigner;
     /**
      *
      * @param key Encoded private key
      * @param passphrase Passphrase to decrypt the private key if it is encrypted
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      *
      */
     constructor(key: string, passphrase?: string);
     /**
      *
-     * @param bytes Bytes to sign
+     * @param message Bytes to sign
      * @param watermark Watermark to append to the bytes
      */
     sign(message: string | Uint8Array, watermark?: Uint8Array): Promise<SignResult>;

package/dist/types/key-interface.d.ts

@@ -11,26 +11,26 @@ export interface SigningKeyWithProofOfPossession extends SigningKey {
 export declare function isPOP(k: SigningKey): k is SigningKeyWithProofOfPossession;
 export interface PublicKey {
     /**
-     * @description Compare two public keys of the same elliptic curve
-     * @param PublicKey the other PublicKey class to compare to
+     * Compare two public keys of the same elliptic curve
+     * @param other the other PublicKey class to compare to
      * @returns -1 if this public key is less than the other, 0 if they are equal, 1 if this public key is greater than the other
-     * @throws {@link InvalidPublicKeyError}
+     * @throws InvalidPublicKeyError
      */
     compare(other: PublicKey): number;
     /**
-     * @description Hash of the public key (tz1, tz2, tz3, tz4 addresses)
+     * Hash of the public key (tz1, tz2, tz3, tz4 addresses)
      * @returns the hash of the public key
      */
     hash(): string;
     /**
-     * @description Get the bytes of the public key without prefix
-     * @param compress: Whether to get the compressed format of the public key
+     * Get the bytes of the public key without prefix
+     * @param compress Whether to get the compressed format of the public key
      * @default true
      * @returns the bytes of the public key
      */
     bytes(compress?: boolean): Uint8Array;
     /**
-     * @description Get the bytes of the public key with prefix
+     * Get the bytes of the public key with prefix
      * @returns the bytes of the public key
      */
     toProtocol(): Uint8Array;

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@taquito/signer",
-  "version": "24.2.0",
-  "description": "Provide signing functionality to be with taquito",
+  "version": "24.3.0-beta.1",
+  "description": "Software signer implementations and signing utilities for Taquito.",
   "keywords": [
+    "taquito",
     "tezos",
+    "typescript",
     "blockchain",
-    "signer"
+    "signer",
+    "crypto"
   ],
   "main": "dist/taquito-signer.umd.js",
   "module": "dist/taquito-signer.es6.js",
@@ -17,14 +20,24 @@
   "publishConfig": {
     "access": "public"
   },
-  "author": "Simon Boissonneault-Robert <simon@ecadlabs.com>",
+  "author": "ECAD Labs Inc <info@ecadlabs.com>",
+  "contributors": [
+    "Jev Björsell (jevonearth)",
+    "Roxane Letourneau <roxane@ecadlabs.com>",
+    "Davis Sawali <davis.sawali@ecadlabs.com>",
+    "Simon Boissonneault-Robert <simon@ecadlabs.com>"
+  ],
+  "homepage": "https://taquito.io/",
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "git+https://github.com/ecadlabs/taquito.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ecadlabs/taquito/issues"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "scripts": {
     "test": "jest --coverage",
@@ -73,8 +86,8 @@
     "@stablelib/nacl": "^1.0.4",
     "@stablelib/pbkdf2": "^1.0.1",
     "@stablelib/sha512": "^1.0.1",
-    "@taquito/core": "^24.2.0",
-    "@taquito/utils": "^24.2.0",
+    "@taquito/core": "^24.3.0-beta.1",
+    "@taquito/utils": "^24.3.0-beta.1",
     "@types/bn.js": "^5.1.5",
     "bip39": "3.1.0",
     "bn.js": "^5.2.2",
@@ -108,8 +121,7 @@
     "ts-jest": "^29.2.3",
     "ts-node": "^10.9.2",
     "ts-toolbelt": "^9.6.0",
-    "typedoc": "^0.26.5",
-    "typescript": "~5.5.4"
+    "typescript": "^5.9.3"
   },
-  "gitHead": "689f242c1780c9fe98c050819c55986912db3934"
+  "gitHead": "551e35aeff7d6dcde1c72284238c0ed3c3aae77e"
 }