How to use rusha - 10 common examples

)
      isWebSeed ? piece.cancelRemaining(reservation) : piece.cancel(reservation)
      onUpdateTick()
      return
    }

    self._debug(
      'got piece %s (offset: %s length: %s) from %s',
      index, chunkOffset, chunkLength, wire.remoteAddress + ':' + wire.remotePort
    )

    if (!piece.set(reservation, chunk, wire)) return onUpdateTick()

    var buf = piece.flush()

    var hexHash = Rusha.createHash().update(buf).digest('hex');
    if (self.destroyed) return

    if (hexHash === self._hashes[index]) {
      if (!self.pieces[index]) return
      self._debug('piece verified %s', index)

      self.pieces[index] = null
      self._reservations[index] = null
      if (!self.bitfield.get(index)) {                      //pear modified
          self.emit('piecefromtorrent', index);
      }
      self.bitfield.set(index, true)
      self.store.put(index, buf)
      // console.log('self.store.put:'+index);
      self.wires.forEach(function (wire) {
        wire.have(index)

// @flow

// Copyright 2016 The Noms Authors. All rights reserved.
// Licensed under the Apache License, version 2.0:
// http://www.apache.org/licenses/LICENSE-2.0

// This is the browser version. The Node.js version is in ../sha1.js.

import Rusha from 'rusha';

const r = new Rusha();

export default function sha1(data: Uint8Array): Uint8Array {
  const ta = r.rawDigest(data);
  return new Uint8Array(ta.buffer, ta.byteOffset, ta.byteLength);
}

// @flow
/* eslint-disable no-bitwise */
import Rusha from 'rusha';

const rusha = new Rusha();

export type Hash = string;
export const EMPTY_HASH: Hash = '0000000000000000000000000000000000000000';

export default function computeHash(input: mixed): Hash {
    const hash = rusha.digest(typeof input === 'object' ? JSON.stringify(input) : input);
    return hash;
}

import Rusha from 'rusha'
import * as CryptoJSlib from '@goodmind/node-cryptojs-aes'
const { CryptoJS } = CryptoJSlib
import { inflate } from 'pako/lib/inflate'

// import Timer from 'hirestime' //TODO remove in prod!

import random from './service/secure-random'


import { eGCD_, greater, divide_, str2bigInt, equalsInt,
  isZero, bigInt2str, copy_, copyInt_, rightShift_,
  leftShift_, sub_, add_, powMod, bpe, one } from './vendor/leemon'


const rushaInstance = new Rusha(1024 * 1024)

export const strDecToHex = str => toLower(
  bigInt2str(
    str2bigInt(str, 10, 0), 16
  ))

export function bytesToHex(bytes = []) {
  const arr = []
  for (let i = 0; i < bytes.length; i++) {
    arr.push((bytes[i] < 16 ? '0' : '') + (bytes[i] || 0).toString(16))
  }
  return arr.join('')
}

export function bytesFromHex(hexString) {
  const len = hexString.length

self.store.get(index, function (err, buf) {
        if (self.destroyed) return cb(new Error('torrent is destroyed'))

        if (err) return process.nextTick(cb, null) // ignore error
        
        var hexHash = Rusha.createHash().update(buf).digest('hex')
        if (self.destroyed) return cb(new Error('torrent is destroyed'))

        if (hexHash === self._hashes[index]) {
          if (!self.pieces[index]) return
          self._debug('piece verified %s', index)
          self._markVerified(index)
        } else {
          self._debug('piece invalid %s', index)
        }
        cb(null)

      })
    }

Validator.prototype.validate = function (data, index) {

    var hash = Rusha.createHash().update(data).digest('hex');
    var equal = hash === this.piecesHash[index];
    if (!equal) {
        console.warn(`[HashValidateError] buffer validate fail ${index} hash ${hash} ref ${this.piecesHash[index]}`);
    }

    return equal;
}

function WebConn (url, torrent) {
  Wire.call(this)

  this.url = url
  this.webPeerId = Rusha.createHash().update(url).digest('hex')
  this._torrent = torrent

  this._init()
}

import Rusha from 'rusha'
import * as CryptoJSlib from '@goodmind/node-cryptojs-aes'
const { CryptoJS } = CryptoJSlib
import { inflate } from 'pako/lib/inflate'

import random from './service/secure-random'

import type { PublicKeyExtended } from './service/main/index.h'

import { eGCD_, greater, divide_, str2bigInt, equalsInt,
  isZero, bigInt2str, copy_, copyInt_, rightShift_,
  leftShift_, sub_, add_, powMod, bpe, one } from 'leemon'


const rushaInstance = new Rusha(1024 * 1024)

export type Bytes = number[]

export function generateNonce() {
  const nonce = new Array(16)
  for (let i = 0; i < 16; i++)
    nonce[i] = nextRandomInt(0xFF)
  return nonce
}


export function bytesToString(bytes: Uint8Array) {
  const ln = bytes.length
  const temp = new Array(ln)
  for (let i = 0; i < ln; ++i)
    temp[i] = String.fromCharCode(bytes[i])

reader.onload = (evt) => {
                if (!evt || !evt.target || !evt.target.result) {
                    reject();
                    return;
                }
                var rusha = new Rusha();
                resolve(base64ArrayBuffer(rusha.rawDigest(evt.target.result).buffer));

            };
            reader.readAsArrayBuffer(blob);

reader.onload = (evt) => {
                if (!evt || !evt.target || !evt.target.result) {
                    reject();
                    return;
                }
                var rusha = new Rusha();
                resolve((rusha.digestFromBuffer(evt.target.result)));

            };
            reader.readAsArrayBuffer(blob);