@ukeyfe/hardware-core 1.1.13

package/src/api/index.ts

@@ -0,0 +1,161 @@
+export { default as testInitializeDeviceDuration } from './test/TestInitializeDeviceDuration';
+
+export { default as searchDevices } from './SearchDevices';
+export { default as getFeatures } from './GetFeatures';
+export { default as getUkeyFeatures } from './GetUkeyFeatures';
+export { default as getPassphraseState } from './GetPassphraseState';
+export { default as getLogs } from './GetLogs';
+export { default as checkFirmwareRelease } from './CheckFirmwareRelease';
+export { default as checkBLEFirmwareRelease } from './CheckBLEFirmwareRelease';
+export { default as checkBridgeStatus } from './CheckBridgeStatus';
+export { default as checkBridgeRelease } from './CheckBridgeRelease';
+export { default as checkBootloaderRelease } from './CheckBootloaderRelease';
+export { default as checkAllFirmwareRelease } from './CheckAllFirmwareRelease';
+export { default as deviceBackup } from './device/DeviceBackup';
+export { default as deviceChangePin } from './device/DeviceChangePin';
+export { default as deviceFlags } from './device/DeviceFlags';
+export { default as deviceRebootToBootloader } from './device/DeviceRebootToBootloader';
+export { default as deviceRebootToBoardloader } from './device/DeviceRebootToBoardloader';
+export { default as deviceRecovery } from './device/DeviceRecovery';
+export { default as deviceReset } from './device/DeviceReset';
+export { default as deviceSettings } from './device/DeviceSettings';
+export { default as deviceUpdateReboot } from './device/DeviceUpdateReboot';
+export { default as deviceUploadResource } from './device/DeviceUploadResource';
+export { default as deviceSupportFeatures } from './device/DeviceSupportFeatures';
+export { default as deviceVerify } from './device/DeviceVerify';
+export { default as deviceWipe } from './device/DeviceWipe';
+export { default as deviceFullyUploadResource } from './device/DeviceFullyUploadResource';
+export { default as deviceUpdateBootloader } from './device/DeviceUpdateBootloader';
+export { default as deviceLock } from './device/DeviceLock';
+export { default as deviceUnlock } from './device/DeviceUnlock';
+export { default as deviceCancel } from './device/DeviceCancel';
+
+export { default as setU2FCounter } from './u2f/SetU2FCounter';
+export { default as getNextU2FCounter } from './u2f/GetNextU2FCounter';
+
+export { default as firmwareUpdate } from './FirmwareUpdate';
+export { default as firmwareUpdateV2 } from './FirmwareUpdateV2';
+export { default as firmwareUpdateV3 } from './FirmwareUpdateV3';
+export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
+export { default as emmcFileWrite } from './EmmcFileWrite';
+
+export { default as cipherKeyValue } from './CipherKeyValue';
+
+export { default as allNetworkGetAddress } from './allnetwork/AllNetworkGetAddress';
+export { default as allNetworkGetAddressByLoop } from './allnetwork/AllNetworkGetAddressByLoop';
+
+export { default as btcGetAddress } from './btc/BTCGetAddress';
+export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';
+export { default as btcSignMessage } from './btc/BTCSignMessage';
+export { default as btcSignPsbt } from './btc/BTCSignPsbt';
+export { default as btcSignTransaction } from './btc/BTCSignTransaction';
+export { default as btcVerifyMessage } from './btc/BTCVerifyMessage';
+
+export { default as confluxGetAddress } from './conflux/ConfluxGetAddress';
+export { default as confluxSignMessage } from './conflux/ConfluxSignMessage';
+export { default as confluxSignMessageCIP23 } from './conflux/ConfluxSignMessageCIP23';
+export { default as confluxSignTransaction } from './conflux/ConfluxSignTransaction';
+
+export { default as evmGetAddress } from './evm/EVMGetAddress';
+export { default as evmGetPublicKey } from './evm/EVMGetPublicKey';
+export { default as evmSignMessage } from './evm/EVMSignMessage';
+export { default as evmSignMessageEIP712 } from './evm/EVMSignMessageEIP712';
+export { default as evmSignTransaction } from './evm/EVMSignTransaction';
+export { default as evmSignTypedData } from './evm/EVMSignTypedData';
+export { default as evmVerifyMessage } from './evm/EVMVerifyMessage';
+
+export { default as starcoinGetAddress } from './starcoin/StarcoinGetAddress';
+export { default as starcoinGetPublicKey } from './starcoin/StarcoinGetPublicKey';
+export { default as starcoinSignMessage } from './starcoin/StarcoinSignMessage';
+export { default as starcoinSignTransaction } from './starcoin/StarcoinSignTransaction';
+export { default as starcoinVerifyMessage } from './starcoin/StarcoinVerifyMessage';
+
+export { default as nemGetAddress } from './nem/NEMGetAddress';
+export { default as nemSignTransaction } from './nem/NEMSignTransaction';
+
+export { default as solGetAddress } from './solana/SolGetAddress';
+export { default as solSignTransaction } from './solana/SolSignTransaction';
+export { default as solSignOffchainMessage } from './solana/SolSignOffchainMessage';
+export { default as solSignMessage } from './solana/SolSignMessage';
+
+export { default as stellarGetAddress } from './stellar/StellarGetAddress';
+export { default as stellarSignTransaction } from './stellar/StellarSignTransaction';
+
+export { default as tronGetAddress } from './tron/TronGetAddress';
+export { default as tronSignMessage } from './tron/TronSignMessage';
+export { default as tronSignTransaction } from './tron/TronSignTransaction';
+
+export { default as nearGetAddress } from './near/NearGetAddress';
+export { default as nearSignTransaction } from './near/NearSignTransaction';
+
+export { default as aptosGetAddress } from './aptos/AptosGetAddress';
+export { default as aptosGetPublicKey } from './aptos/AptosGetPublicKey';
+export { default as aptosSignTransaction } from './aptos/AptosSignTransaction';
+export { default as aptosSignMessage } from './aptos/AptosSignMessage';
+export { default as aptosSignInMessage } from './aptos/AptosSignInMessage';
+
+export { default as algoGetAddress } from './algo/AlgoGetAddress';
+export { default as algoSignTransaction } from './algo/AlgoSignTransaction';
+
+export { default as cosmosGetAddress } from './cosmos/CosmosGetAddress';
+export { default as cosmosGetPublicKey } from './cosmos/CosmosGetPublicKey';
+export { default as cosmosSignTransaction } from './cosmos/CosmosSignTransaction';
+
+export { default as xrpGetAddress } from './xrp/XrpGetAddress';
+export { default as xrpSignTransaction } from './xrp/XrpSignTransaction';
+
+export { default as suiGetAddress } from './sui/SuiGetAddress';
+export { default as suiGetPublicKey } from './sui/SuiGetPublicKey';
+export { default as suiSignMessage } from './sui/SuiSignMessage';
+export { default as suiSignTransaction } from './sui/SuiSignTransaction';
+
+export { default as cardanoGetAddress } from './cardano/CardanoGetAddress';
+export { default as cardanoGetPublicKey } from './cardano/CardanoGetPublicKey';
+export { default as cardanoSignTransaction } from './cardano/CardanoSignTransaction';
+export { default as cardanoSignMessage } from './cardano/CardanoSignMessage';
+
+export { default as filecoinGetAddress } from './filecoin/FilecoinGetAddress';
+export { default as filecoinSignTransaction } from './filecoin/FilecoinSignTransaction';
+
+export { default as polkadotGetAddress } from './polkadot/PolkadotGetAddress';
+export { default as polkadotSignTransaction } from './polkadot/PolkadotSignTransaction';
+
+export { default as kaspaGetAddress } from './kaspa/KaspaGetAddress';
+export { default as kaspaSignTransaction } from './kaspa/KaspaSignTransaction';
+
+export { default as nexaGetAddress } from './nexa/NexaGetAddress';
+export { default as nexaSignTransaction } from './nexa/NexaSignTransaction';
+
+export { default as nostrGetPublicKey } from './nostr/NostrGetPublicKey';
+export { default as nostrSignEvent } from './nostr/NostrSignEvent';
+export { default as nostrEncryptMessage } from './nostr/NostrEncryptMessage';
+export { default as nostrDecryptMessage } from './nostr/NostrDecryptMessage';
+export { default as nostrSignSchnorr } from './nostr/NostrSignSchnorr';
+
+export { default as lnurlAuth } from './lightning/LnurlAuth';
+
+export { default as nervosGetAddress } from './nervos/NervosGetAddress';
+export { default as nervosSignTransaction } from './nervos/NervosSignTransaction';
+
+export { default as dnxGetAddress } from './dynex/DnxGetAddress';
+export { default as dnxSignTransaction } from './dynex/DnxSignTransaction';
+
+export { default as tonGetAddress } from './ton/TonGetAddress';
+export { default as tonSignMessage } from './ton/TonSignMessage';
+export { default as tonSignProof } from './ton/TonSignProof';
+
+export { default as scdoGetAddress } from './scdo/ScdoGetAddress';
+export { default as scdoSignTransaction } from './scdo/ScdoSignTransaction';
+export { default as scdoSignMessage } from './scdo/ScdoSignMessage';
+
+export { default as alephiumGetAddress } from './alephium/AlephiumGetAddress';
+export { default as alephiumSignTransaction } from './alephium/AlephiumSignTransaction';
+export { default as alephiumSignMessage } from './alephium/AlephiumSignMessage';
+
+export { default as benfenGetAddress } from './benfen/BenfenGetAddress';
+export { default as benfenGetPublicKey } from './benfen/BenfenGetPublicKey';
+export { default as benfenSignMessage } from './benfen/BenfenSignMessage';
+export { default as benfenSignTransaction } from './benfen/BenfenSignTransaction';
+
+export { default as neoGetAddress } from './neo/NeoGetAddress';
+export { default as neoSignTransaction } from './neo/NeoSignTransaction';

package/src/api/kaspa/KaspaGetAddress.ts

@@ -0,0 +1,102 @@
+import { KaspaGetAddress as HardwareKaspaGetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { KaspaGetAddressParams, KaspaAddress } from '../../types';
+
+export default class KaspaGetAddress extends BaseMethod<HardwareKaspaGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: KaspaGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'prefix', type: 'string' },
+        { name: 'scheme', type: 'string' },
+        { name: 'useTweak', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        prefix: batch.prefix,
+        scheme: batch.scheme,
+        use_tweak: batch.useTweak,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.3.0',
+      },
+    };
+  }
+
+  getUseTweakVersionRange() {
+    return {
+      pro: {
+        min: '4.14.0',
+      },
+      model_classic1s: {
+        min: '3.12.0',
+      },
+    };
+  }
+
+  async run() {
+    this.checkFeatureVersionLimit(
+      // exists use_tweak is false check firmware version
+      () => this.params.some(param => param.use_tweak === false),
+      () => this.getUseTweakVersionRange(),
+      {
+        strictCheckDeviceSupport: true,
+      }
+    );
+
+    const responses: KaspaAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+      const res = await this.device.commands.typedCall('KaspaGetAddress', 'KaspaAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+      };
+      responses.push(result);
+      this.postPreviousAddressMessage(result);
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -0,0 +1,180 @@
+import { bytesToHex } from '@noble/hashes/utils';
+import { TypedCall } from '@ukeyfe/hardware-transport';
+import { TypedResponseMessage } from '../../device/DeviceCommands';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  KaspaSignInputParams,
+  KaspaSignOutputParams,
+  KaspaSignTransactionParams,
+  KaspaSignature,
+} from '../../types';
+import { zeroSubnetworkID, serialize } from './helpers/TransferSerialize';
+import { SignatureType } from './helpers/SignatureType';
+
+export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactionParams> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const payload = this.payload as KaspaSignTransactionParams;
+
+    // check payload
+    validateParams(payload, [
+      { name: 'version', type: 'number' },
+      { name: 'sigHashType', type: 'number', required: true },
+      { name: 'inputs', type: 'array', required: true },
+      { name: 'outputs', type: 'array', required: true },
+      { name: 'lockTime', required: true },
+      { name: 'sigOpCount', type: 'number' },
+      { name: 'subNetworkID', type: 'string' },
+      { name: 'useTweak', type: 'boolean' },
+    ]);
+
+    // if(!payload.inputs.length) throw
+
+    const inputs: KaspaSignInputParams[] = payload.inputs.map(input => {
+      validateParams(input, [
+        { name: 'path', type: 'string', required: true },
+        { name: 'prevTxId', type: 'string', required: true },
+        { name: 'outputIndex', type: 'number', required: true },
+        { name: 'sequenceNumber', required: true },
+      ]);
+
+      const addressN = validatePath(input.path, 3);
+
+      return {
+        ...input,
+        path: addressN,
+        sigOpCount: input.sigOpCount ?? 1, // input.script.getSignatureOperationsCount()) //sigOpCount
+      };
+    });
+
+    const outputs: KaspaSignOutputParams[] = payload.outputs.map(output => {
+      validateParams(output, [
+        { name: 'satoshis', required: true },
+        { name: 'script', type: 'string', required: true },
+        { name: 'scriptVersion', type: 'number' },
+      ]);
+
+      return {
+        ...output,
+        scriptVersion: output.scriptVersion ?? 0,
+      };
+    });
+
+    this.params = {
+      ...payload,
+      inputs,
+      outputs,
+      scheme: payload.scheme ?? 'schnorr',
+      prefix: payload.prefix ?? 'kaspa',
+      // eslint-disable-next-line no-bitwise
+      sigHashType: payload.sigHashType ?? SignatureType.SIGHASH_ALL | SignatureType.SIGHASH_FORKID,
+      sigOpCount: payload.sigOpCount ?? 1,
+      subNetworkID: payload.subNetworkID ?? bytesToHex(zeroSubnetworkID()),
+      useTweak: payload.useTweak,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.3.0',
+      },
+    };
+  }
+
+  getUseTweakVersionRange() {
+    return {
+      pro: {
+        min: '4.14.0',
+      },
+      model_classic1s: {
+        min: '3.12.0',
+      },
+    };
+  }
+
+  async processTxRequest(
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'KaspaTxInputRequest'> | TypedResponseMessage<'KaspaSignedTx'>,
+    index: number,
+    signature: KaspaSignature[]
+  ): Promise<KaspaSignature[]> {
+    if (res.type === 'KaspaSignedTx') {
+      signature.push({
+        index,
+        signature: res.message.signature,
+      });
+
+      return signature;
+    }
+
+    if (res.type === 'KaspaTxInputRequest') {
+      signature.push({
+        index,
+        signature: res.message.signature ?? '',
+      });
+
+      const nextIndex = res.message.request_index;
+
+      const { raw: rawMessage } = serialize(this.params, nextIndex);
+      const input = this.params.inputs[nextIndex];
+
+      const response = await typedCall(
+        'KaspaTxInputAck',
+        // @ts-expect-error
+        ['KaspaTxInputRequest', 'KaspaSignedTx'],
+        {
+          address_n: input.path,
+          raw_message: bytesToHex(rawMessage),
+        }
+      );
+
+      // @ts-expect-error
+      return this.processTxRequest(typedCall, response, nextIndex, signature);
+    }
+
+    return signature;
+  }
+
+  async run() {
+    this.checkFeatureVersionLimit(
+      // exists use_tweak is false check firmware version
+      () => this.params.useTweak === false,
+      () => this.getUseTweakVersionRange(),
+      {
+        strictCheckDeviceSupport: true,
+      }
+    );
+
+    const { raw: rawMessage } = serialize(this.params, 0);
+    const input = this.params.inputs[0];
+
+    const { device, params } = this;
+
+    // @ts-expect-error
+    const response = await device.commands.typedCall(
+      'KaspaSignTx',
+      ['KaspaTxInputRequest', 'KaspaSignedTx'],
+      {
+        address_n: input.path,
+        raw_message: bytesToHex(rawMessage),
+        scheme: params.scheme,
+        prefix: params.prefix,
+        input_count: params.inputs.length,
+        use_tweak: params.useTweak,
+      }
+    );
+
+    return this.processTxRequest(device.commands.typedCall.bind(device.commands), response, 0, []);
+  }
+}

package/src/api/kaspa/helpers/BufferWriter.ts

@@ -0,0 +1,177 @@
+import BigNumber from 'bignumber.js';
+import { Buffer } from 'buffer';
+
+function isBuffer(arg: any) {
+  return Buffer.isBuffer(arg) || arg instanceof Uint8Array;
+}
+
+function bigNumberToBuffer(bn: BigNumber, options: { size: number }): Buffer {
+  const hex = bn.toString(16);
+  const paddedHex = hex.padStart(options.size * 2, '0');
+  return Buffer.from(paddedHex, 'hex');
+}
+
+class BufferWriter {
+  bufLen: number;
+
+  // @ts-expect-error
+  bufs: Buffer[];
+
+  constructor(obj?: Partial<BufferWriter>) {
+    this.bufLen = 0;
+    if (obj) {
+      this.set(obj);
+    } else {
+      this.bufs = [];
+    }
+  }
+
+  public set(obj: Partial<BufferWriter>): this {
+    this.bufs = obj.bufs || this.bufs || [];
+    this.bufLen = this.bufs.reduce((prev, buf) => prev + buf.length, 0);
+    return this;
+  }
+
+  public toBuffer(): Buffer {
+    return this.concat();
+  }
+
+  public concat(): Buffer {
+    return Buffer.concat(this.bufs, this.bufLen);
+  }
+
+  public write(buf: Buffer): this {
+    if (!isBuffer(buf)) throw new Error('BufferWriter.write: Invalid type');
+    this.bufs.push(buf);
+    this.bufLen += buf.length;
+    return this;
+  }
+
+  public writeReverse(buf: Buffer): this {
+    if (!isBuffer(buf)) throw new Error('BufferWriter.write: Invalid type');
+    this.bufs.push(buf.reverse());
+    this.bufLen += buf.length;
+    return this;
+  }
+
+  public writeVarBytes(buf: Buffer): this {
+    if (!isBuffer(buf)) throw new Error('BufferWriter.write: Invalid type');
+    this.writeUInt64LE(new BigNumber(buf.length));
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt8(n: number): this {
+    const buf = Buffer.alloc(1);
+    buf.writeUInt8(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt16BE(n: number): this {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16BE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt16LE(n: number): this {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16LE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt32BE(n: number): this {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeInt32LE(n: number): this {
+    const buf = Buffer.alloc(4);
+    buf.writeInt32LE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt32LE(n: number): this {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32LE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt64BEBN(bn: BigNumber): this {
+    const buf = bigNumberToBuffer(bn, { size: 8 });
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt64LE(bn: BigNumber): this {
+    const buf = bigNumberToBuffer(bn, { size: 8 });
+    this.writeReverse(buf);
+    return this;
+  }
+
+  public writeVarintNum(n: number): this {
+    const buf = BufferWriter.varintBufNum(n);
+    this.write(buf);
+    return this;
+  }
+
+  public writeVarintBN(bn: BigNumber): this {
+    const buf = BufferWriter.varintBufBN(bn);
+    this.write(buf);
+    return this;
+  }
+
+  public static varintBufNum(n: number): Buffer {
+    let buf: Buffer;
+    if (n < 253) {
+      buf = Buffer.alloc(1);
+      buf.writeUInt8(n, 0);
+    } else if (n < 0x10000) {
+      buf = Buffer.alloc(1 + 2);
+      buf.writeUInt8(253, 0);
+      buf.writeUInt16LE(n, 1);
+    } else if (n < 0x100000000) {
+      buf = Buffer.alloc(1 + 4);
+      buf.writeUInt8(254, 0);
+      buf.writeUInt32LE(n, 1);
+    } else {
+      buf = Buffer.alloc(1 + 8);
+      buf.writeUInt8(255, 0);
+      // eslint-disable-next-line no-bitwise
+      buf.writeInt32LE(n & -1, 1);
+      buf.writeUInt32LE(Math.floor(n / 0x100000000), 5);
+    }
+    return buf;
+  }
+
+  public static varintBufBN(bn: BigNumber): Buffer {
+    let buf: Buffer;
+    const n = bn.toNumber();
+    if (n < 253) {
+      buf = Buffer.alloc(1);
+      buf.writeUInt8(n, 0);
+    } else if (n < 0x10000) {
+      buf = Buffer.alloc(1 + 2);
+      buf.writeUInt8(253, 0);
+      buf.writeUInt16LE(n, 1);
+    } else if (n < 0x100000000) {
+      buf = Buffer.alloc(1 + 4);
+      buf.writeUInt8(254, 0);
+      buf.writeUInt32LE(n, 1);
+    } else {
+      const bw = new BufferWriter();
+      bw.writeUInt8(255);
+      bw.writeUInt64LE(bn);
+      buf = bw.concat();
+    }
+    return buf;
+  }
+}
+
+export default BufferWriter;

package/src/api/kaspa/helpers/HashWriter.ts

@@ -0,0 +1,72 @@
+import { blake2b } from '@noble/hashes/blake2b';
+import BigNumber from 'bignumber.js';
+import { Hash } from '@noble/hashes/utils';
+import BufferWriter from './BufferWriter';
+
+const TransactionSigningHashKey = Buffer.from('TransactionSigningHash');
+
+class HashWriter {
+  private blake2b: Hash<any>;
+
+  bw: BufferWriter;
+
+  hash: {
+    update: (buf: Buffer) => void;
+    digest: () => Buffer;
+  };
+
+  constructor() {
+    this.bw = new BufferWriter();
+    this.blake2b = blake2b.create({ dkLen: 32, key: TransactionSigningHashKey });
+    this.hash = {
+      update: (buf: Buffer) => {
+        this.bw.write(buf);
+        this.blake2b.update(buf);
+      },
+      digest: () => Buffer.from(this.blake2b.digest()),
+    };
+  }
+
+  writeUInt8(value: number): void {
+    const buf = new BufferWriter();
+    buf.writeUInt8(value);
+    this.hash.update(buf.toBuffer());
+  }
+
+  writeUInt16LE(value: number): void {
+    const buf = new BufferWriter();
+    buf.writeUInt16LE(value);
+    this.hash.update(buf.toBuffer());
+  }
+
+  writeUInt32LE(value: number): void {
+    const buf = new BufferWriter();
+    buf.writeUInt32LE(value);
+    this.hash.update(buf.toBuffer());
+  }
+
+  writeUInt64LE(value: BigNumber.Value): void {
+    const buf = new BufferWriter();
+    buf.writeUInt64LE(new BigNumber(value));
+    this.hash.update(buf.toBuffer());
+  }
+
+  writeVarBytes(buf: Buffer): void {
+    this.writeUInt64LE(buf.length);
+    this.hash.update(buf);
+  }
+
+  writeHash(buf: Buffer): void {
+    this.hash.update(buf);
+  }
+
+  finalize(): Buffer {
+    return this.hash.digest();
+  }
+
+  toBuffer(): Buffer {
+    return this.bw.toBuffer();
+  }
+}
+
+export { HashWriter };