@aeternity/aepp-sdk 12.0.0 → 12.1.2

package/src/Node.ts

@@ -1,40 +1,88 @@
-import BigNumber from 'bignumber.js'
-import { OperationArguments, OperationSpec } from '@azure/core-client'
+// eslint-disable-next-line max-classes-per-file
+import BigNumber from 'bignumber.js';
+import { OperationArguments, OperationSpec } from '@azure/core-client';
 import {
   genRequestQueuesPolicy, genCombineGetRequestsPolicy, genErrorFormatterPolicy,
-  genVersionCheckPolicy
-} from './utils/autorest'
-import { Node as NodeApi, NodeOptionalParams, ErrorModel } from './apis/node/'
-import { mapObject } from './utils/other'
-import { EncodedData } from './utils/encoder'
-import { MissingParamError } from './utils/errors'
+  genVersionCheckPolicy,
+} from './utils/autorest';
+import { Node as NodeApi, NodeOptionalParams, ErrorModel } from './apis/node';
+import { mapObject } from './utils/other';
+import { Encoded } from './utils/encoder';
+import { MissingParamError } from './utils/errors';
 
 /**
  * Obtain networkId from account or node
  */
-export async function getNetworkId ({ networkId }: { networkId?: string } = {}): Promise<string> {
-  const res = networkId ?? this.networkId ?? (await this.api?.getStatus()).networkId
-  if (res != null) return res
-  throw new MissingParamError('networkId is not provided')
+export async function getNetworkId({ networkId }: { networkId?: string } = {}): Promise<string> {
+  const res = networkId ?? this.networkId ?? (await this.api?.getStatus())?.networkId;
+  if (res != null) return res;
+  throw new MissingParamError('networkId is not provided');
 }
 
 const bigIntPropertyNames = [
   'balance', 'queryFee', 'fee', 'amount', 'nameFee', 'channelAmount',
   'initiatorAmount', 'responderAmount', 'channelReserve', 'initiatorAmountFinal',
-  'responderAmountFinal', 'gasPrice', 'deposit'
-] as const
+  'responderAmountFinal', 'gasPrice', 'deposit',
+] as const;
 
 const numberPropertyNames = [
   'time', 'gas', 'gasUsed', 'nameSalt',
-  'nonce', 'nextNonce', 'height', 'blockHeight', 'top', 'topBlockHeight', 'ttl',
+  'nonce', 'nextNonce', 'height', 'blockHeight', 'top', 'topBlockHeight',
+  'ttl', 'nameTtl', 'clientTtl',
   'inbound', 'outbound', 'peerCount', 'pendingTransactionsCount', 'effectiveAtHeight',
-  'version', 'solutions'
-] as const
+  'version', 'solutions', 'round',
+] as const;
 
-type BigIntPropertyNames = typeof bigIntPropertyNames[number]
-type NumberPropertyNames = typeof numberPropertyNames[number]
+class NodeTransformed extends NodeApi {
+  async sendOperationRequest(
+    operationArguments: OperationArguments,
+    operationSpec: OperationSpec,
+  ): Promise<any> {
+    const args = mapObject(
+      operationArguments,
+      ([key, value]) => [key, this.#encodeArg(value)],
+    ) as OperationArguments;
+    return this.#decodeRes(await super.sendOperationRequest(args, operationSpec));
+  }
+
+  #mapData(data: any, transform: {
+    bigInt: (v: any) => any;
+    number: (v: any) => any;
+  }): unknown {
+    if (Array.isArray(data)) return data.map((d) => this.#mapData(d, transform));
+    if (data != null && typeof data === 'object') {
+      return mapObject(data, ([key, value]) => {
+        if (value == null) return [key, value];
+        if (bigIntPropertyNames.some((k) => k === key)) return [key, transform.bigInt(value)];
+        if (numberPropertyNames.some((k) => k === key)) return [key, transform.number(value)];
+        return [key, this.#mapData(value, transform)];
+      });
+    }
+    return data;
+  }
+
+  #encodeArg(data: any): any {
+    return this.#mapData(data, {
+      bigInt: (value) => {
+        if (value instanceof BigNumber) return value.toFixed();
+        return value.toString();
+      },
+      number: (value) => value.toString(),
+    });
+  }
+
+  #decodeRes(data: any): any {
+    return this.#mapData(data, {
+      bigInt: (value) => BigInt(value),
+      number: (value) => +value,
+    });
+  }
+}
+
+type BigIntPropertyNames = typeof bigIntPropertyNames[number];
+type NumberPropertyNames = typeof numberPropertyNames[number];
 type PreserveOptional<NewType, OrigType> =
-  OrigType extends undefined ? NewType | undefined : NewType
+  OrigType extends undefined ? NewType | undefined : NewType;
 export type TransformNodeType<Type> =
   Type extends (...args: infer Args) => infer Ret
     ? (...args: TransformNodeType<Args>) => TransformNodeType<Ret>
@@ -46,38 +94,40 @@ export type TransformNodeType<Type> =
           ? Promise<TransformNodeType<T>>
           : Type extends { [P in any]: any }
             ? {
-                [Property in keyof Type]:
-                Property extends BigIntPropertyNames
-                  ? PreserveOptional<bigint, Type[Property]>
-                  : Property extends NumberPropertyNames
-                    ? PreserveOptional<number, Type[Property]>
-                    : Property extends 'txHash'
-                      ? PreserveOptional<EncodedData<'th'>, Type[Property]>
-                      : TransformNodeType<Type[Property]>
-              }
-            : Type
-type TransformedNode = new (...args: ConstructorParameters<typeof NodeApi>) => {
-  [Name in keyof InstanceType<typeof NodeApi>]: TransformNodeType<NodeApi[Name]>
-}
+              [Property in keyof Type]:
+              Property extends BigIntPropertyNames
+                ? PreserveOptional<bigint, Type[Property]>
+                : Property extends NumberPropertyNames
+                  ? PreserveOptional<number, Type[Property]>
+                  : Property extends 'txHash'
+                    ? PreserveOptional<Encoded.TxHash, Type[Property]>
+                    : TransformNodeType<Type[Property]>
+            }
+            : Type;
+type NodeTransformedApi = new (...args: ConstructorParameters<typeof NodeApi>) => {
+  [Name in keyof InstanceType<typeof NodeApi>]:
+  Name extends 'pipeline' | 'sendRequest' | 'sendOperationRequest'
+    ? NodeApi[Name] : TransformNodeType<NodeApi[Name]>
+};
 
 export interface NodeInfo {
-  url: string
-  nodeNetworkId: string
-  version: string
-  consensusProtocolVersion: number
+  url: string;
+  nodeNetworkId: string;
+  version: string;
+  consensusProtocolVersion: number;
 }
 
-export default class Node extends (NodeApi as unknown as TransformedNode) {
-  url: string
+export default class Node extends (NodeTransformed as unknown as NodeTransformedApi) {
+  url: string;
 
   /**
    * @param url - Url for node API
    * @param options - Options
    * @param options.ignoreVersion - Don't check node version
    */
-  constructor (
+  constructor(
     url: string,
-    { ignoreVersion = false, ...options }: NodeOptionalParams & { ignoreVersion?: boolean } = {}
+    { ignoreVersion = false, ...options }: NodeOptionalParams & { ignoreVersion?: boolean } = {},
   ) {
     // eslint-disable-next-line constructor-super
     super(url, {
@@ -85,83 +135,39 @@ export default class Node extends (NodeApi as unknown as TransformedNode) {
       additionalPolicies: [
         genRequestQueuesPolicy(),
         genCombineGetRequestsPolicy(),
-        genErrorFormatterPolicy((body: ErrorModel) => ` ${body.reason}`)
+        genErrorFormatterPolicy((body: ErrorModel) => ` ${body.reason}`),
       ],
-      ...options
-    })
-    this.url = url
+      ...options,
+    });
+    this.url = url;
     if (!ignoreVersion) {
-      const versionPromise = this.getStatus().then(({ nodeVersion }) => nodeVersion)
-      this.pipeline.addPolicy(genVersionCheckPolicy('node', '/v3/status', versionPromise, '6.2.0', '7.0.0'))
+      const versionPromise = this.getStatus().then(({ nodeVersion }) => nodeVersion);
+      this.pipeline.addPolicy(
+        genVersionCheckPolicy('node', '/v3/status', versionPromise, '6.2.0', '7.0.0'),
+      );
     }
-    this.intAsString = true
+    this.intAsString = true;
   }
 
-  async getNodeInfo (): Promise<NodeInfo> {
+  async getNodeInfo(): Promise<NodeInfo> {
     const {
       nodeVersion: version,
       networkId: nodeNetworkId,
       protocols,
-      topBlockHeight
-    } = await this.getStatus()
+      topBlockHeight,
+    } = await this.getStatus();
     const consensusProtocolVersion = protocols
       .filter(({ effectiveAtHeight }) => topBlockHeight >= effectiveAtHeight)
       .reduce(
-        (acc, p) => p.effectiveAtHeight > acc.effectiveAtHeight ? p : acc,
-        { effectiveAtHeight: -1, version: 0 }
+        (acc, p) => (p.effectiveAtHeight > acc.effectiveAtHeight ? p : acc),
+        { effectiveAtHeight: -1, version: 0 },
       )
-      .version
+      .version;
     return {
       url: this.url,
       nodeNetworkId,
       version,
-      consensusProtocolVersion
-    }
-  }
-
-  // @ts-expect-error https://github.com/microsoft/TypeScript/issues/27689
-  async sendOperationRequest (
-    operationArguments: OperationArguments, operationSpec: OperationSpec
-  ): Promise<any> {
-    const args = mapObject(
-      operationArguments,
-      ([key, value]) => [key, this.#encodeArg(value)]
-    ) as OperationArguments
-    return this.#decodeRes(await super.sendOperationRequest(args, operationSpec))
-  }
-
-  #mapData (
-    data: any, transform: {
-      bigInt: (v: any) => any
-      number: (v: any) => any
-    }
-  ): unknown {
-    if (Array.isArray(data)) return data.map(d => this.#mapData(d, transform))
-    if (data != null && typeof data === 'object') {
-      return mapObject(data, ([key, value]) => {
-        if (value == null) return [key, value]
-        if (bigIntPropertyNames.some(k => k === key)) return [key, transform.bigInt(value)]
-        if (numberPropertyNames.some(k => k === key)) return [key, transform.number(value)]
-        return [key, this.#mapData(value, transform)]
-      })
-    }
-    return data
-  }
-
-  #encodeArg (data: any): any {
-    return this.#mapData(data, {
-      bigInt: value => {
-        if (value instanceof BigNumber) return value.toFixed()
-        return value.toString()
-      },
-      number: value => value.toString()
-    })
-  }
-
-  #decodeRes (data: any): any {
-    return this.#mapData(data, {
-      bigInt: value => BigInt(value),
-      number: value => +value
-    })
+      consensusProtocolVersion,
+    };
   }
 }

package/src/account/Base.ts

@@ -14,33 +14,35 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import { messageToHash, verifyMessage as verifyMessageCrypto, hash } from '../utils/crypto'
-import { buildTx } from '../tx/builder'
-import { decode, EncodedData } from '../utils/encoder'
-import { TX_TYPE } from '../tx/builder/schema'
-import { getNetworkId } from '../Node'
-import { concatBuffers } from '../utils/other'
+import { messageToHash, verifyMessage as verifyMessageCrypto, hash } from '../utils/crypto';
+import { buildTx } from '../tx/builder';
+import { decode, Encoded } from '../utils/encoder';
+import { Tag } from '../tx/builder/constants';
+import { getNetworkId } from '../Node';
+import { concatBuffers } from '../utils/other';
+import type { createMetaTx } from '../contract/ga';
 
 /**
  * Check is provided object looks like an instance of AccountBase
  * @param acc - Object to check
  */
-export const isAccountBase = (acc: AccountBase | any): boolean =>
-  !['sign', 'address', 'signTransaction', 'signMessage'].some(f => typeof acc[f] !== 'function')
+export const isAccountBase = (acc: AccountBase | any): boolean => (
+  !['sign', 'address', 'signTransaction', 'signMessage'].some((f) => typeof acc[f] !== 'function')
+);
 
 /**
  * Account is one of the three basic building blocks of an
  * {@link AeSdk} and provides access to a signing key pair.
  */
 export default abstract class AccountBase {
-  networkId?: string
+  networkId?: string;
 
   /**
    * @param options - Options
    * @param options.networkId - Using for signing transactions
    */
-  constructor ({ networkId }: { networkId?: string } = {}) {
-    this.networkId ??= networkId
+  constructor({ networkId }: { networkId?: string } = {}) {
+    this.networkId ??= networkId;
   }
 
   /**
@@ -50,24 +52,29 @@ export default abstract class AccountBase {
    * @param opt.innerTx - Sign as inner transaction for PayingFor
    * @returns Signed transaction
    */
-  async signTransaction (
-    tx: EncodedData<'tx'>,
-    { innerTx, networkId, ...options }: { innerTx?: boolean, networkId?: string } = {}
-  ): Promise<EncodedData<'tx'>> {
-    const prefixes = [await this.getNetworkId({ networkId })]
-    if (innerTx === true) prefixes.push('inner_tx')
-    const rlpBinaryTx = decode(tx)
-    const txWithNetworkId = concatBuffers([Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)])
+  async signTransaction(
+    tx: Encoded.Transaction,
+    { innerTx, networkId, ...options }: {
+      innerTx?: boolean;
+      networkId?: string;
+      authData?: Parameters<typeof createMetaTx>[1];
+      authFun?: Parameters<typeof createMetaTx>[2];
+    } & Omit<Partial<Parameters<typeof createMetaTx>[3]>, 'onAccount'> = {},
+  ): Promise<Encoded.Transaction> {
+    const prefixes = [await this.getNetworkId({ networkId })];
+    if (innerTx === true) prefixes.push('inner_tx');
+    const rlpBinaryTx = decode(tx);
+    const txWithNetworkId = concatBuffers([Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)]);
 
-    const signatures = [await this.sign(txWithNetworkId, options)]
-    return buildTx({ encodedTx: rlpBinaryTx, signatures }, TX_TYPE.signed).tx
+    const signatures = [await this.sign(txWithNetworkId, options)];
+    return buildTx({ encodedTx: rlpBinaryTx, signatures }, Tag.SignedTx).tx;
   }
 
   /**
    * Get network Id
    * @returns Network Id
    */
-  readonly getNetworkId = getNetworkId
+  readonly getNetworkId = getNetworkId;
 
   /**
    * Sign message
@@ -75,11 +82,12 @@ export default abstract class AccountBase {
    * @param opt - Options
    * @returns Signature as hex string of Uint8Array
    */
-  async signMessage (
-    message: string, { returnHex = false, ...options }: { returnHex?: boolean } = {}
+  async signMessage(
+    message: string,
+    { returnHex = false, ...options }: { returnHex?: boolean } = {},
   ): Promise<string | Uint8Array> {
-    const sig = await this.sign(messageToHash(message), options)
-    return returnHex ? Buffer.from(sig).toString('hex') : sig
+    const sig = await this.sign(messageToHash(message), options);
+    return returnHex ? Buffer.from(sig).toString('hex') : sig;
   }
 
   /**
@@ -88,14 +96,16 @@ export default abstract class AccountBase {
    * @param signature - Signature
    * @param options - Options
    */
-  async verifyMessage (
-    message: string, signature: string | Uint8Array, options?: object
+  async verifyMessage(
+    message: string,
+    signature: string | Uint8Array,
+    options?: object,
   ): Promise<boolean> {
     return verifyMessageCrypto(
       message,
       typeof signature === 'string' ? Buffer.from(signature, 'hex') : signature,
-      decode(await this.address(options))
-    )
+      decode(await this.address(options)),
+    );
   }
 
   /**
@@ -104,11 +114,11 @@ export default abstract class AccountBase {
    * @param options - Options
    * @returns Signed data blob
    */
-  abstract sign (data: string | Uint8Array, options?: any): Promise<Uint8Array>
+  abstract sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
 
   /**
    * Obtain account address
    * @returns Public account address
    */
-  abstract address (opt?: object): Promise<EncodedData<'ak'>>
+  abstract address(opt?: object): Promise<Encoded.AccountAddress>;
 }

package/src/account/Memory.ts

@@ -14,25 +14,25 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import AccountBase from './Base'
-import { sign, isValidKeypair } from '../utils/crypto'
-import { isHex } from '../utils/string'
-import { decode } from '../tx/builder/helpers'
-import { InvalidKeypairError, MissingParamError } from '../utils/errors'
-import { EncodedData } from '../utils/encoder'
+import AccountBase from './Base';
+import { sign, isValidKeypair } from '../utils/crypto';
+import { isHex } from '../utils/string';
+import { ArgumentError, InvalidKeypairError, MissingParamError } from '../utils/errors';
+import { decode, Encoded } from '../utils/encoder';
+import { createMetaTx } from '../contract/ga';
 
-const secrets = new WeakMap()
+const secrets = new WeakMap();
 
 export interface Keypair {
-  publicKey: EncodedData<'ak'>
-  secretKey: string | Uint8Array
+  publicKey: Encoded.AccountAddress;
+  secretKey: string | Uint8Array;
 }
 
 /**
  * In-memory account class
  */
 export default class AccountMemory extends AccountBase {
-  isGa: boolean
+  isGa: boolean;
 
   /**
    * @param options - Options
@@ -41,43 +41,58 @@ export default class AccountMemory extends AccountBase {
    * @param options.keypair.secretKey - Private key
    * @param options.gaId - Address of generalized account
    */
-  constructor (
-    { keypair, gaId, ...options }: { keypair?: Keypair, gaId?: EncodedData<'ak'> } & ConstructorParameters<typeof AccountBase>[0]
+  constructor(
+    { keypair, gaId, ...options }: { keypair?: Keypair; gaId?: Encoded.AccountAddress }
+    & ConstructorParameters<typeof AccountBase>[0],
   ) {
-    super(options)
+    super(options);
 
-    this.isGa = gaId != null
+    this.isGa = gaId != null;
     if (this.isGa && gaId != null) {
-      decode(gaId)
-      secrets.set(this, { publicKey: gaId })
-      return
+      decode(gaId);
+      secrets.set(this, { publicKey: gaId });
+      return;
     }
 
-    if (keypair == null) throw new MissingParamError('Either gaId or keypair is required')
+    if (keypair == null) throw new MissingParamError('Either gaId or keypair is required');
 
     if (
-      !Buffer.isBuffer(keypair.secretKey) &&
-      typeof keypair.secretKey === 'string' && !isHex(keypair.secretKey)
-    ) throw new InvalidKeypairError('Secret key must be hex string or Buffer')
+      !Buffer.isBuffer(keypair.secretKey)
+      && typeof keypair.secretKey === 'string' && !isHex(keypair.secretKey)
+    ) throw new InvalidKeypairError('Secret key must be hex string or Buffer');
     const secretKey = typeof keypair.secretKey === 'string'
       ? Buffer.from(keypair.secretKey, 'hex')
-      : keypair.secretKey
+      : keypair.secretKey;
     if (!isValidKeypair(secretKey, decode(keypair.publicKey))) {
-      throw new InvalidKeypairError('Invalid Key Pair')
+      throw new InvalidKeypairError('Invalid Key Pair');
     }
 
     secrets.set(this, {
       secretKey,
-      publicKey: keypair.publicKey
-    })
+      publicKey: keypair.publicKey,
+    });
   }
 
-  async sign (data: string | Uint8Array): Promise<Uint8Array> {
-    if (this.isGa) throw new InvalidKeypairError('You are trying to sign data using generalized account without keypair')
-    return sign(data, secrets.get(this).secretKey)
+  async sign(data: string | Uint8Array): Promise<Uint8Array> {
+    if (this.isGa) throw new InvalidKeypairError('You are trying to sign data using generalized account without keypair');
+    return sign(data, secrets.get(this).secretKey);
   }
 
-  async address (): Promise<EncodedData<'ak'>> {
-    return secrets.get(this).publicKey
+  async signTransaction(
+    tx: Encoded.Transaction,
+    options: Parameters<AccountBase['signTransaction']>[1] = {},
+  ): Promise<Encoded.Transaction> {
+    if (!this.isGa || options.innerTx === true) return super.signTransaction(tx, options);
+    const {
+      authData, authFun, onCompiler, onNode,
+    } = options;
+    if (authFun == null || authData == null || onCompiler == null || onNode == null) {
+      throw new ArgumentError('authData, authFun, onCompiler, onNode', 'provided', null);
+    }
+    return createMetaTx(tx, authData, authFun, { onCompiler, onNode, onAccount: this });
+  }
+
+  async address(): Promise<Encoded.AccountAddress> {
+    return secrets.get(this).publicKey;
   }
 }

package/src/account/Rpc.ts

@@ -1,7 +1,7 @@
-import AccountBase from './Base'
-import { METHODS } from '../aepp-wallet-communication/schema'
-import { NotImplementedError } from '../utils/errors'
-import { EncodedData } from '../utils/encoder'
+import AccountBase from './Base';
+import { METHODS } from '../aepp-wallet-communication/schema';
+import { NotImplementedError } from '../utils/errors';
+import { Encoded } from '../utils/encoder';
 
 /**
  * Account provided by wallet
@@ -11,34 +11,36 @@ import { EncodedData } from '../utils/encoder'
  * @returns AccountRpc instance
  */
 export default class AccountRpc extends AccountBase {
-  _rpcClient: any
-  _address: EncodedData<'ak'>
+  _rpcClient: any;
 
-  constructor (
-    { rpcClient, address, ...options }:
-    { rpcClient: any, address: EncodedData<'ak'> } & ConstructorParameters<typeof AccountBase>[0]
+  _address: Encoded.AccountAddress;
+
+  constructor(
+    { rpcClient, address, ...options }: { rpcClient: any; address: Encoded.AccountAddress }
+    & ConstructorParameters<typeof AccountBase>[0],
   ) {
-    super(options)
-    this._rpcClient = rpcClient
-    this._address = address
+    super(options);
+    this._rpcClient = rpcClient;
+    this._address = address;
   }
 
-  async sign (data: string | Uint8Array, options?: any): Promise<Uint8Array> {
-    throw new NotImplementedError('RAW signing using wallet')
+  // eslint-disable-next-line class-methods-use-this
+  async sign(): Promise<Uint8Array> {
+    throw new NotImplementedError('RAW signing using wallet');
   }
 
-  async address (): Promise<EncodedData<'ak'>> {
-    return this._address
+  async address(): Promise<Encoded.AccountAddress> {
+    return this._address;
   }
 
   /**
    * @returns Signed transaction
    */
-  async signTransaction (
-    tx: EncodedData<'tx'>,
-    { innerTx, networkId }: Parameters<AccountBase['signTransaction']>[1] = {}
-  ): Promise<EncodedData<'tx'>> {
-    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountRpc')
+  async signTransaction(
+    tx: Encoded.Transaction,
+    { innerTx, networkId }: Parameters<AccountBase['signTransaction']>[1] = {},
+  ): Promise<Encoded.Transaction> {
+    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountRpc');
     const res = await this._rpcClient.request(METHODS.sign, {
       onAccount: this._address,
       tx,
@@ -48,20 +50,20 @@ export default class AccountRpc extends AccountBase {
        * required to maintain backward compatibility with wallets using SDK v11.0.1 and below
        * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
        */
-      networkId
-    })
-    return res.signedTransaction
+      networkId,
+    });
+    return res.signedTransaction;
   }
 
   /**
    * @returns Signed message
    */
-  async signMessage (
-    message: string, { returnHex = false }: Parameters<AccountBase['signMessage']>[1] = {}
+  async signMessage(
+    message: string,
+    { returnHex = false }: Parameters<AccountBase['signMessage']>[1] = {},
   ): Promise<string | Uint8Array> {
-    const { signature } = await this._rpcClient.request(
-      METHODS.signMessage, { onAccount: this._address, message }
-    )
-    return returnHex ? signature : Buffer.from(signature, 'hex')
+    const { signature } = await this._rpcClient
+      .request(METHODS.signMessage, { onAccount: this._address, message });
+    return returnHex ? signature : Buffer.from(signature, 'hex');
   }
 }