koilib 2.6.1 → 3.0.0

package/lib/Signer.d.ts

@@ -1,15 +1,15 @@
 import { Provider } from "./Provider";
-import { TransactionJson, ActiveTransactionData, Abi, SendTransactionResponse, RecoverPublicKeyOptions, BlockJson } from "./interface";
-import { Serializer } from "./Serializer";
+import { TransactionJson, TransactionJsonWait, BlockJson, RecoverPublicKeyOptions, Abi } from "./interface";
 export interface SignerInterface {
     provider?: Provider;
-    serializer?: Serializer;
     getAddress: (compressed?: boolean) => string;
     getPrivateKey: (format: "wif" | "hex", compressed?: boolean) => string;
-    signTransaction: (tx: TransactionJson) => Promise<TransactionJson>;
-    sendTransaction: (tx: TransactionJson, abis?: Record<string, Abi>) => Promise<SendTransactionResponse>;
-    encodeTransaction: (activeData: ActiveTransactionData) => Promise<TransactionJson>;
-    decodeTransaction: (tx: TransactionJson) => Promise<ActiveTransactionData>;
+    signHash(hash: Uint8Array): Promise<Uint8Array>;
+    signTransaction: (tx: TransactionJson | TransactionJsonWait, abis?: Record<string, Abi>) => Promise<TransactionJson>;
+    sendTransaction: (tx: TransactionJson | TransactionJsonWait, abis?: Record<string, Abi>) => Promise<TransactionJsonWait>;
+    prepareTransaction: (tx: TransactionJson) => Promise<TransactionJson>;
+    prepareBlock: (block: BlockJson) => Promise<BlockJson>;
+    signBlock: (block: BlockJson) => Promise<BlockJson>;
 }
 /**
  * The Signer Class contains the private key needed to sign transactions.
@@ -78,13 +78,13 @@ export declare class Signer implements SignerInterface {
      */
     address: string;
     /**
-     * Provider to connect with the blockchain
+     * Chain id
      */
-    provider?: Provider;
+    chainId: string;
     /**
-     * Serializer to serialize/deserialize data types
+     * Provider to connect with the blockchain
      */
-    serializer?: Serializer;
+    provider?: Provider;
     /**
      * The constructor receives de private key as hexstring, bigint or Uint8Array.
      * See also the functions [[Signer.fromWif]] and [[Signer.fromSeed]]
@@ -104,14 +104,8 @@ export declare class Signer implements SignerInterface {
     constructor(c: {
         privateKey: string | number | bigint | Uint8Array;
         compressed?: boolean;
+        chainId?: string;
         provider?: Provider;
-        /**
-         * Set this option if you can not use _eval_ functions
-         * in the current environment. In such cases, the
-         * serializer must come from an environment where it
-         * is able to use those functions.
-         */
-        serializer?: Serializer;
     });
     /**
      * Function to import a private key from the WIF
@@ -124,7 +118,7 @@ export declare class Signer implements SignerInterface {
      * ```
      * @returns Signer object
      */
-    static fromWif(wif: string): Signer;
+    static fromWif(wif: string, compressed?: boolean): Signer;
     /**
      * Function to import a private key from the seed
      * @param seed - Seed words
@@ -163,13 +157,26 @@ export declare class Signer implements SignerInterface {
      * ```
      */
     getPrivateKey(format?: "wif" | "hex", compressed?: boolean): string;
+    /**
+     * Function to sign a hash value. It returns the bytes signature.
+     * The signature is in compact format with the recovery byte
+     * @param hash - Hash value. Also known as digest
+     */
+    signHash(hash: Uint8Array): Promise<Uint8Array>;
     /**
      * Function to sign a transaction. It's important to remark that
      * the transaction parameter is modified inside this function.
      * @param tx - Unsigned transaction
-     * @returns
      */
-    signTransaction(tx: TransactionJson): Promise<TransactionJson>;
+    signTransaction(tx: TransactionJson | TransactionJsonWait, _abis?: Record<string, Abi>): Promise<TransactionJson>;
+    /**
+     * Function to sign a block for federated consensus. That is,
+     * just the ecdsa signature. For other algorithms, like PoW,
+     * you have to sign the block and then process the signature
+     * to add the extra data (nonce in the case of PoW).
+     * @param block - Unsigned block
+     */
+    signBlock(block: BlockJson): Promise<BlockJson>;
     /**
      * Function to sign and send a transaction. It internally uses
      * [[Provider.sendTransaction]]
@@ -179,15 +186,22 @@ export declare class Signer implements SignerInterface {
      * transaction. This parameter is optional.
      * @returns
      */
-    sendTransaction(tx: TransactionJson, _abis?: Record<string, Abi>): Promise<SendTransactionResponse>;
+    sendTransaction(tx: TransactionJson | TransactionJsonWait, _abis?: Record<string, Abi>): Promise<TransactionJsonWait>;
+    /**
+     * Function to recover the public key from hash and signature
+     * @param hash - hash sha256
+     * @param signature - compact signature
+     * @param compressed - default true
+     */
+    static recoverPublicKey(hash: Uint8Array, signature: Uint8Array, compressed?: boolean): string;
     /**
-     * Function to recover the public key from a signed
+     * Function to recover the publics keys from a signed
      * transaction or block.
      * The output format can be compressed (default) or uncompressed.
      *
      * @example
      * ```ts
-     * const publicKey = await Signer.recoverPublicKey(tx);
+     * const publicKeys = await Signer.recoverPublicKeys(tx);
      * ```
      *
      * If the signature data contains more data, like in the
@@ -221,7 +235,7 @@ export declare class Signer implements SignerInterface {
      *   defaultTypeName: "pow_signature_data",
      *  });
      *
-     *  const signer = await Signer.recoverPublicKey(block, {
+     *  const publicKeys = await signer.recoverPublicKeys(block, {
      *    transformSignature: async (signatureData) => {
      *      const powSignatureData = await serializer.deserialize(signatureData);
      *      return powSignatureData.recoverable_signature;
@@ -229,14 +243,14 @@ export declare class Signer implements SignerInterface {
      *  });
      * ```
      */
-    static recoverPublicKey(txOrBlock: TransactionJson | BlockJson, opts?: RecoverPublicKeyOptions): Promise<string>;
+    recoverPublicKeys(txOrBlock: TransactionJson | BlockJson, opts?: RecoverPublicKeyOptions): Promise<string[]>;
     /**
-     * Function to recover the signer address from a signed
+     * Function to recover the signer addresses from a signed
      * transaction or block.
      * The output format can be compressed (default) or uncompressed.
      * @example
      * ```ts
-     * const publicKey = await Signer.recoverAddress(tx);
+     * const addresses = await signer.recoverAddress(tx);
      * ```
      *
      * If the signature data contains more data, like in the
@@ -270,7 +284,7 @@ export declare class Signer implements SignerInterface {
      *   defaultTypeName: "pow_signature_data",
      *  });
      *
-     *  const signer = await Signer.recoverAddress(block, {
+     *  const addresses = await signer.recoverAddress(block, {
      *    transformSignature: async (signatureData) => {
      *      const powSignatureData = await serializer.deserialize(signatureData);
      *      return powSignatureData.recoverable_signature;
@@ -278,19 +292,19 @@ export declare class Signer implements SignerInterface {
      *  });
      * ```
      */
-    static recoverAddress(txOrBlock: TransactionJson | BlockJson, opts?: RecoverPublicKeyOptions): Promise<string>;
+    recoverAddresses(txOrBlock: TransactionJson | BlockJson, opts?: RecoverPublicKeyOptions): Promise<string[]>;
     /**
-     * Function to encode a transaction
-     * @param activeData - Active data consists of nonce, rc_limit, and
-     * operations. Do not set the nonce to get it from the blockchain
-     * using the provider. The rc_limit is 1000000 by default.
-     * @returns A transaction encoded. The active field is encoded in
-     * base64url
+     * Function to prepare a transaction
+     * @param tx - Do not set the nonce to get it from the blockchain
+     * using the provider. The rc_limit is 1e8 by default.
+     * @returns A prepared transaction. ()
      */
-    encodeTransaction(activeData: ActiveTransactionData): Promise<TransactionJson>;
+    prepareTransaction(tx: TransactionJson): Promise<TransactionJson>;
     /**
-     * Function to decode a transaction
+     * Function to prepare a block
+     * @param block -
+     * @returns A prepared block. ()
      */
-    decodeTransaction(tx: TransactionJson): Promise<ActiveTransactionData>;
+    prepareBlock(block: BlockJson): Promise<BlockJson>;
 }
 export default Signer;