How to use ripemd160 - 9 common examples

async namePreorder(namespace: string,
                     name: string,
                     salt: string,
                     STX: number, 
                     params: { sender: string }): Promise {
    let fqn = `${name}.${namespace}`;
    let sha256 = new shajs.sha256().update(fqn).digest();
    let hash160 = new ripemd160().update(sha256).digest('hex');
    let hashedFqn = `0x${hash160}`;
    console.log(hashedFqn);
    const tx = this.createTransaction({
      method: { name: "name-preorder", args: [`${hashedFqn}`, `u${STX}`] }
    });
    await tx.sign(params.sender);
    const res = await this.submitTransaction(tx);
    return res;
  }

async namespacePreorder(namespace: string, 
                          salt: string,
                          STX: number, 
                          params: { sender: string }): Promise {
    if (namespace === '') {
      throw new Error("Namespace can't be empty");
    }
    if (STX <= 0) {
      throw new Error("STX should be non-zero positive");
    }

    let sha256 = new shajs.sha256().update(`${namespace}${salt}`).digest();
    let hash160 = new ripemd160().update(sha256).digest('hex');
    let hashedNamespace = `0x${hash160}`;
    const tx = this.createTransaction({
      method: { name: "namespace-preorder", args: [`${hashedNamespace}`, `u${STX}`] }
    });
    await tx.sign(params.sender);
    const res = await this.submitTransaction(tx);
    return res;
  }

export function pubKeyAddress(pubKey) {
    const encKey = new Writer();
    writeObject(encKey, new Buffer(pubKey.inner));

    const hasher = new ripemd160();
    hasher.update(new Buffer([typeEd25519]));
    hasher.update(encKey.getBuffer());
    return new Uint8Array(hasher.digest())
}

static fromPublicKey(publicKey: Uint8Array): LocalAddress {
    if (publicKey.length !== 32) {
      throw new Error(`Invalid public key, expected 32 bytes, go ${publicKey.length}`)
    }
    const hasher = new ripemd160()
    hasher.update(
      Buffer.from(publicKey.buffer as ArrayBuffer, publicKey.byteOffset, publicKey.byteLength)
    )
    return new LocalAddress(hasher.digest())
  }
}

export function addressFromPubKey(pubKeyHex: string): string {
  var ec = new EC('secp256k1');
  var key = ByteBuffer.fromHex(decodePubKey(pubKeyHex));
  const hashResult = shajs('sha256')
    .update(key.view)
    .digest() as string;
  var addr = new RIPEMD160().update(hashResult).digest('hex');
  return addr;
}

ripemd160(data) {
        data = data.toString(base);
        return require('ripemd160')(data).toString('hex');
    },
    sha1(data) {