@taquito/core 23.0.0-beta.0 → 23.0.0

package/dist/taquito-core.umd.js

@@ -7,6 +7,23 @@
   // ==========================================================================================
   // parent error classes for Taquito
   // ==========================================================================================
+  exports.ValidationResult = void 0;
+  (function (ValidationResult) {
+      ValidationResult[ValidationResult["NO_PREFIX_MATCHED"] = 0] = "NO_PREFIX_MATCHED";
+      ValidationResult[ValidationResult["INVALID_CHECKSUM"] = 1] = "INVALID_CHECKSUM";
+      ValidationResult[ValidationResult["INVALID_LENGTH"] = 2] = "INVALID_LENGTH";
+      ValidationResult[ValidationResult["VALID"] = 3] = "VALID";
+      ValidationResult[ValidationResult["PREFIX_NOT_ALLOWED"] = 4] = "PREFIX_NOT_ALLOWED";
+      ValidationResult[ValidationResult["INVALID_ENCODING"] = 5] = "INVALID_ENCODING";
+      ValidationResult[ValidationResult["OTHER"] = 6] = "OTHER";
+  })(exports.ValidationResult || (exports.ValidationResult = {}));
+  const resultDesc = {
+      [exports.ValidationResult.NO_PREFIX_MATCHED]: 'unsupported Base58 prefix',
+      [exports.ValidationResult.INVALID_CHECKSUM]: 'invalid checksum',
+      [exports.ValidationResult.INVALID_LENGTH]: 'invalid length',
+      [exports.ValidationResult.PREFIX_NOT_ALLOWED]: 'Base58 prefix not allowed in this context',
+      [exports.ValidationResult.INVALID_ENCODING]: 'invalid Base58 encoding',
+  };
   /**
    *  @category Error
    *  @description Parent error class all taquito errors to extend from
@@ -18,6 +35,39 @@
    *  @description Error that indicates invalid user inputs
    */
   class ParameterValidationError extends TaquitoError {
+      constructor(message, validationResult, errorDetail) {
+          let detail;
+          let result;
+          let msg;
+          if (message !== undefined) {
+              if (typeof message === 'string') {
+                  msg = message;
+                  if (validationResult !== undefined) {
+                      if (typeof validationResult === 'string') {
+                          detail = validationResult;
+                      }
+                      else {
+                          result = validationResult;
+                          if (errorDetail !== undefined) {
+                              detail = errorDetail;
+                          }
+                          else {
+                              detail = resultDesc[validationResult];
+                          }
+                      }
+                  }
+              }
+              else {
+                  result = message;
+                  detail = resultDesc[message];
+                  msg = detail;
+              }
+          }
+          super(msg);
+          this.name = this.constructor.name;
+          this.result = result;
+          this.errorDetail = detail;
+      }
   }
   /**
    *  @category Error
@@ -58,30 +108,30 @@
    */
   class InvalidAddressError extends ParameterValidationError {
       constructor(address, errorDetail) {
-          super();
+          super(`Invalid address "${address}"`, errorDetail);
           this.address = address;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidAddressError';
-          this.message = `Invalid address "${address}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
+      }
+  }
+  class InvalidProofError extends ParameterValidationError {
+      constructor(proof, errorDetail) {
+          super(`Invalid proof "${proof}"`, errorDetail);
+          this.proof = proof;
+          this.name = this.constructor.name;
       }
   }
   class InvalidStakingAddressError extends ParameterValidationError {
       constructor(address, errorDetail) {
-          super();
+          super(`Invalid staking address "${address}", you can only set destination as your own address`, errorDetail);
           this.address = address;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidStakingAddressError';
-          this.message = `Invalid staking address "${address}", you can only set destination as your own address`;
+          this.name = this.constructor.name;
       }
   }
   class InvalidFinalizeUnstakeAmountError extends ParameterValidationError {
       constructor(address, errorDetail) {
-          super();
+          super(`The amount can only be 0 when finalizing an unstake`, errorDetail);
           this.address = address;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidFinalizeUnstakeAmountError';
-          this.message = `The amount can only be 0 when finalizing an unstake`;
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -90,12 +140,9 @@
    */
   class InvalidBlockHashError extends ParameterValidationError {
       constructor(blockHash, errorDetail) {
-          super();
+          super(`Invalid block hash "${blockHash}"`, errorDetail);
           this.blockHash = blockHash;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidBlockHashError';
-          this.message = `Invalid block hash "${blockHash}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -103,11 +150,10 @@
    * @description Error that indicates an invalid amount of tez being passed as a parameter
    */
   class InvalidAmountError extends ParameterValidationError {
-      constructor(amount) {
-          super();
+      constructor(amount, errorDetail) {
+          super(`Invalid amount "${amount}"`, errorDetail);
           this.amount = amount;
-          this.name = 'InvalidAmountError';
-          this.message = `Invalid amount "${amount}"`;
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -116,12 +162,9 @@
    */
   class InvalidDerivationPathError extends ParameterValidationError {
       constructor(derivationPath, errorDetail) {
-          super();
+          super(`Invalid derivation path "${derivationPath}"`, errorDetail);
           this.derivationPath = derivationPath;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidDerivationPathError';
-          this.message = `Invalid derivation path "${derivationPath}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -130,12 +173,9 @@
    */
   class InvalidHexStringError extends ParameterValidationError {
       constructor(hexString, errorDetail) {
-          super();
+          super(`Invalid hex string "${hexString}"`, errorDetail);
           this.hexString = hexString;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidHexStringError';
-          this.message = `Invalid hex string "${hexString}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -144,12 +184,9 @@
    */
   class InvalidMessageError extends ParameterValidationError {
       constructor(msg, errorDetail) {
-          super();
+          super(`Invalid message "${msg}"`, errorDetail);
           this.msg = msg;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidMessageError';
-          this.message = `Invalid message "${msg}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -157,14 +194,14 @@
    *  @description Error that indicates invalid view parameter of a smart contract
    */
   class InvalidViewParameterError extends ParameterValidationError {
-      constructor(viewName, sigs, args, cause) {
-          super();
+      constructor(viewName, sigs, args, cause, errorDetail) {
+          const message = `Invalid view arguments ${JSON.stringify(args)} received for name "${viewName}" expecting one of the following signatures ${JSON.stringify(sigs)}.`;
+          super(message, errorDetail);
           this.viewName = viewName;
           this.sigs = sigs;
           this.args = args;
           this.cause = cause;
-          this.name = 'InvalidViewParameterError';
-          this.message = `Invalid view arguments ${JSON.stringify(args)} received for name "${viewName}" expecting one of the following signatures ${JSON.stringify(sigs)}.`;
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -173,11 +210,8 @@
    */
   class InvalidKeyError extends ParameterValidationError {
       constructor(errorDetail) {
-          super();
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidKeyError';
-          this.message = `Invalid private key`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          super(`Invalid private key`, errorDetail);
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -186,12 +220,10 @@
    */
   class InvalidPublicKeyError extends ParameterValidationError {
       constructor(publicKey, errorDetail) {
-          super();
+          const msg = publicKey !== undefined ? `Invalid public key "${publicKey}"` : `Invalid public key`;
+          super(msg, errorDetail);
           this.publicKey = publicKey;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidPublicKeyError';
-          this.message = `Invalid public key "${publicKey}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -200,12 +232,9 @@
    */
   class InvalidSignatureError extends ParameterValidationError {
       constructor(signature, errorDetail) {
-          super();
+          super(`Invalid signature "${signature}"`, errorDetail);
           this.signature = signature;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidSignatureError';
-          this.message = `Invalid signature "${signature}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -214,12 +243,9 @@
    */
   class InvalidContractAddressError extends ParameterValidationError {
       constructor(contractAddress, errorDetail) {
-          super();
+          super(`Invalid contract address "${contractAddress}"`, errorDetail);
           this.contractAddress = contractAddress;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidContractAddressError';
-          this.message = `Invalid contract address "${contractAddress}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -228,12 +254,9 @@
    */
   class InvalidChainIdError extends ParameterValidationError {
       constructor(chainId, errorDetail) {
-          super();
+          super(`Invalid chain id "${chainId}"`, errorDetail);
           this.chainId = chainId;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidChainIdError';
-          this.message = `Invalid chain id "${chainId}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -242,12 +265,9 @@
    */
   class InvalidKeyHashError extends ParameterValidationError {
       constructor(keyHash, errorDetail) {
-          super();
+          super(`Invalid public key hash "${keyHash}"`, errorDetail);
           this.keyHash = keyHash;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidKeyHashError';
-          this.message = `Invalid public key hash "${keyHash}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -256,12 +276,9 @@
    */
   class InvalidOperationHashError extends ParameterValidationError {
       constructor(operationHash, errorDetail) {
-          super();
+          super(`Invalid operation hash "${operationHash}"`, errorDetail);
           this.operationHash = operationHash;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidOperationHashError';
-          this.message = `Invalid operation hash "${operationHash}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -270,12 +287,9 @@
    */
   class InvalidOperationKindError extends ParameterValidationError {
       constructor(operationKind, errorDetail) {
-          super();
+          super(`Invalid operation kind "${operationKind}"`, errorDetail);
           this.operationKind = operationKind;
-          this.errorDetail = errorDetail;
-          this.name = 'InvalidOperationKindError';
-          this.message = `Invalid operation kind "${operationKind}"`;
-          this.message += errorDetail ? ` ${errorDetail}.` : '.';
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -284,9 +298,8 @@
    */
   class DeprecationError extends UnsupportedActionError {
       constructor(message) {
-          super();
-          this.message = message;
-          this.name = 'DeprecationError';
+          super(message);
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -295,9 +308,8 @@
    */
   class ProhibitedActionError extends UnsupportedActionError {
       constructor(message) {
-          super();
-          this.message = message;
-          this.name = 'ProhibitedActionError';
+          super(message);
+          this.name = this.constructor.name;
       }
   }
   /**
@@ -306,11 +318,10 @@
    */
   class PublicKeyNotFoundError extends TaquitoError {
       constructor(pkh, cause) {
-          super();
+          super(`Public key not found of this address "${pkh}" in either wallet or contract API.`);
           this.pkh = pkh;
           this.cause = cause;
-          this.name = 'PublicKeyNotFoundError';
-          this.message = `Public key not found of this address "${pkh}" in either wallet or contract API.`;
+          this.name = this.constructor.name;
       }
   }
 
@@ -328,6 +339,7 @@
   exports.InvalidMessageError = InvalidMessageError;
   exports.InvalidOperationHashError = InvalidOperationHashError;
   exports.InvalidOperationKindError = InvalidOperationKindError;
+  exports.InvalidProofError = InvalidProofError;
   exports.InvalidPublicKeyError = InvalidPublicKeyError;
   exports.InvalidSignatureError = InvalidSignatureError;
   exports.InvalidStakingAddressError = InvalidStakingAddressError;

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

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

package/dist/types/errors.d.ts

@@ -1,3 +1,12 @@
+export declare enum ValidationResult {
+    NO_PREFIX_MATCHED = 0,
+    INVALID_CHECKSUM = 1,
+    INVALID_LENGTH = 2,
+    VALID = 3,
+    PREFIX_NOT_ALLOWED = 4,
+    INVALID_ENCODING = 5,
+    OTHER = 6
+}
 /**
  *  @category Error
  *  @description Parent error class all taquito errors to extend from
@@ -9,6 +18,11 @@ export declare class TaquitoError extends Error {
  *  @description Error that indicates invalid user inputs
  */
 export declare class ParameterValidationError extends TaquitoError {
+    readonly errorDetail?: string;
+    readonly result?: ValidationResult;
+    constructor(validationResult?: ValidationResult);
+    constructor(message?: string, errorDetail?: string | ValidationResult);
+    constructor(message?: string, validationResult?: ValidationResult, errorDetail?: string);
 }
 /**
  *  @category Error
@@ -46,18 +60,19 @@ export declare class PermissionDeniedError extends TaquitoError {
  */
 export declare class InvalidAddressError extends ParameterValidationError {
     readonly address: string;
-    readonly errorDetail?: string | undefined;
-    constructor(address: string, errorDetail?: string | undefined);
+    constructor(address: string, errorDetail?: string | ValidationResult);
+}
+export declare class InvalidProofError extends ParameterValidationError {
+    readonly proof: string;
+    constructor(proof: string, errorDetail?: string | ValidationResult);
 }
 export declare class InvalidStakingAddressError extends ParameterValidationError {
     readonly address: string;
-    readonly errorDetail?: string | undefined;
-    constructor(address: string, errorDetail?: string | undefined);
+    constructor(address: string, errorDetail?: string | ValidationResult);
 }
 export declare class InvalidFinalizeUnstakeAmountError extends ParameterValidationError {
     readonly address: string;
-    readonly errorDetail?: string | undefined;
-    constructor(address: string, errorDetail?: string | undefined);
+    constructor(address: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -65,8 +80,7 @@ export declare class InvalidFinalizeUnstakeAmountError extends ParameterValidati
  */
 export declare class InvalidBlockHashError extends ParameterValidationError {
     readonly blockHash: string;
-    readonly errorDetail?: string | undefined;
-    constructor(blockHash: string, errorDetail?: string | undefined);
+    constructor(blockHash: string, errorDetail?: string | ValidationResult);
 }
 /**
  * @category Error
@@ -74,7 +88,7 @@ export declare class InvalidBlockHashError extends ParameterValidationError {
  */
 export declare class InvalidAmountError extends ParameterValidationError {
     readonly amount: string;
-    constructor(amount: string);
+    constructor(amount: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -82,8 +96,7 @@ export declare class InvalidAmountError extends ParameterValidationError {
  */
 export declare class InvalidDerivationPathError extends ParameterValidationError {
     readonly derivationPath: string;
-    readonly errorDetail?: string | undefined;
-    constructor(derivationPath: string, errorDetail?: string | undefined);
+    constructor(derivationPath: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -91,8 +104,7 @@ export declare class InvalidDerivationPathError extends ParameterValidationError
  */
 export declare class InvalidHexStringError extends ParameterValidationError {
     readonly hexString: string;
-    readonly errorDetail?: string | undefined;
-    constructor(hexString: string, errorDetail?: string | undefined);
+    constructor(hexString: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -100,8 +112,7 @@ export declare class InvalidHexStringError extends ParameterValidationError {
  */
 export declare class InvalidMessageError extends ParameterValidationError {
     readonly msg: string;
-    readonly errorDetail?: string | undefined;
-    constructor(msg: string, errorDetail?: string | undefined);
+    constructor(msg: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -112,24 +123,22 @@ export declare class InvalidViewParameterError extends ParameterValidationError
     readonly sigs: any;
     readonly args: any;
     readonly cause?: any;
-    constructor(viewName: string, sigs: any, args: any, cause?: any);
+    constructor(viewName: string, sigs: any, args: any, cause?: any, errorDetail?: string);
 }
 /**
  *  @category Error
  *  @description Error that indicates an invalid private key being passed or used
  */
 export declare class InvalidKeyError extends ParameterValidationError {
-    readonly errorDetail?: string | undefined;
-    constructor(errorDetail?: string | undefined);
+    constructor(errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
  *  @description Error that indicates an Invalid Public Key being passed or used
  */
 export declare class InvalidPublicKeyError extends ParameterValidationError {
-    readonly publicKey: string;
-    readonly errorDetail?: string | undefined;
-    constructor(publicKey: string, errorDetail?: string | undefined);
+    readonly publicKey?: string | undefined;
+    constructor(publicKey?: string | undefined, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -137,8 +146,7 @@ export declare class InvalidPublicKeyError extends ParameterValidationError {
  */
 export declare class InvalidSignatureError extends ParameterValidationError {
     readonly signature: string;
-    readonly errorDetail?: string | undefined;
-    constructor(signature: string, errorDetail?: string | undefined);
+    constructor(signature: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -146,8 +154,7 @@ export declare class InvalidSignatureError extends ParameterValidationError {
  */
 export declare class InvalidContractAddressError extends ParameterValidationError {
     readonly contractAddress: string;
-    readonly errorDetail?: string | undefined;
-    constructor(contractAddress: string, errorDetail?: string | undefined);
+    constructor(contractAddress: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -155,8 +162,7 @@ export declare class InvalidContractAddressError extends ParameterValidationErro
  */
 export declare class InvalidChainIdError extends ParameterValidationError {
     readonly chainId: string;
-    readonly errorDetail?: string | undefined;
-    constructor(chainId: string, errorDetail?: string | undefined);
+    constructor(chainId: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -164,8 +170,7 @@ export declare class InvalidChainIdError extends ParameterValidationError {
  */
 export declare class InvalidKeyHashError extends ParameterValidationError {
     readonly keyHash: string;
-    readonly errorDetail?: string | undefined;
-    constructor(keyHash: string, errorDetail?: string | undefined);
+    constructor(keyHash: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -173,8 +178,7 @@ export declare class InvalidKeyHashError extends ParameterValidationError {
  */
 export declare class InvalidOperationHashError extends ParameterValidationError {
     readonly operationHash: string;
-    readonly errorDetail?: string | undefined;
-    constructor(operationHash: string, errorDetail?: string | undefined);
+    constructor(operationHash: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
@@ -182,15 +186,13 @@ export declare class InvalidOperationHashError extends ParameterValidationError
  */
 export declare class InvalidOperationKindError extends ParameterValidationError {
     readonly operationKind: string;
-    readonly errorDetail?: string | undefined;
-    constructor(operationKind: string, errorDetail?: string | undefined);
+    constructor(operationKind: string, errorDetail?: string | ValidationResult);
 }
 /**
  *  @category Error
  *  @description General error that indicates something is no longer supported and/or deprecated
  */
 export declare class DeprecationError extends UnsupportedActionError {
-    readonly message: string;
     constructor(message: string);
 }
 /**
@@ -198,7 +200,6 @@ export declare class DeprecationError extends UnsupportedActionError {
  *  @description General error that indicates an action is prohibited or not allowed
  */
 export declare class ProhibitedActionError extends UnsupportedActionError {
-    readonly message: string;
     constructor(message: string);
 }
 /**

package/dist/types/signer-interfaces.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @description Signer interface which is used across taquito in order to sign and inject operation
+ */
+export interface Signer {
+    /**
+     * @param op Message to sign
+     * @param magicByte Magic bytes 11 for block, 12 for preattestation, 13 for attestation, 3 for generic, 5 for the PACK format of michelson
+     * @description Sign the message and return an object with bytes, sig, prefixSig and sbytes
+     */
+    sign(op: string, magicByte?: Uint8Array): Promise<SignResult>;
+    /**
+     * @description Return the public key of the account used by the signer
+     */
+    publicKey(): Promise<string>;
+    /**
+     * @description Return the public key hash of the account used by the signer
+     */
+    publicKeyHash(): Promise<string>;
+    /**
+     * @description Optionally return the secret key of the account used by the signer
+     */
+    secretKey(): Promise<string | undefined>;
+    /**
+     * @description Sign the public key to prove possession for bls key and return an object with bytes, sig, prefixSig and sbytes
+     */
+    provePossession?(): Promise<RawSignResult>;
+}
+export interface SignResult {
+    bytes: string;
+    sig: string;
+    prefixSig: string;
+    sbytes: string;
+}
+export interface RawSignResult {
+    sig: string;
+    prefixSig: string;
+    rawSignature: Uint8Array;
+}

package/dist/types/taquito-core.d.ts

@@ -3,3 +3,4 @@
  * @module @taquito/core
  */
 export * from './errors';
+export * from './signer-interfaces';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/core",
-  "version": "23.0.0-beta.0",
+  "version": "23.0.0",
   "description": "Classes, interfaces, and types shared across Taquito packages",
   "keywords": [
     "tezos",
@@ -68,5 +68,5 @@
     "rollup": "^4.22.4",
     "rollup-plugin-typescript2": "^0.36.0"
   },
-  "gitHead": "37cc766d60407d7909fbd2d841d9dd946243d04a"
+  "gitHead": "4ac77876be144da54f292e639b5b977a13642de9"
 }