How to use sha3 - 10 common examples

(parseInt(nextMessage?.sentDate, 10) || 0) - (sentDate || 0) < 60000 // one minute
		} else {
			isFollowupMessage =
				previousMessage && !inte.isMe && inte.memberPublicKey === previousMessage.memberPublicKey
			isFollowedMessage =
				nextMessage && !inte.isMe && inte.memberPublicKey === nextMessage.memberPublicKey

			isWithinCollapseDuration =
				nextMessage &&
				inte?.memberPublicKey === nextMessage?.memberPublicKey &&
				sentDate &&
				nextMessage.sentDate &&
				(parseInt(nextMessage?.sentDate, 10) || 0) - (sentDate || 0) < 60000 // one minute

			if (!inte.isMe && inte.memberPublicKey) {
				const h = new SHA3(256).update(inte.memberPublicKey).digest()
				baseColor = '#' + pal[h[0]]
			}
			msgTextColor = inte.isMe
				? inte.acknowledged
					? color.white
					: cmd
					? color.grey
					: baseColor
				: baseColor
			msgBackgroundColor = inte.isMe
				? inte.acknowledged
					? baseColor
					: color.white
				: Color(baseColor).alpha(0.1).string()
			msgBorderColor = inte.isMe && (cmd ? border.color.grey : { borderColor: baseColor })
			msgSenderColor = inte.isMe ? 'red' : baseColor

const senderAccountState = await this.getAccountState(senderAddress)
      sequenceNumber = senderAccountState.sequenceNumber
    }

    const rawTransaction = new RawTransaction()
    rawTransaction.setSenderAccount(senderAddress.toBytes())
    rawTransaction.setSequenceNumber(sequenceNumber.toNumber())
    rawTransaction.setProgram(transaction.program)
    rawTransaction.setMaxGasAmount(transaction.gasContraint.maxGasAmount.toNumber())
    rawTransaction.setGasUnitPrice(transaction.gasContraint.gasUnitPrice.toNumber())
    rawTransaction.setExpirationTime(transaction.expirationTime.toNumber())

    const signedTransaction = new SignedTransaction()
    signedTransaction.setSenderPublicKey(sender.keyPair.getPublicKey())

    const sha3 = new SHA3(256)
    // Magic number provided by Libra
    sha3.update('46f174df6ca8de5ad29745f91584bb913e7df8dd162e3e921a5c1d8637c88d16', 'hex')
    sha3.update(new Buffer(rawTransaction.serializeBinary()))

    signedTransaction.setSenderSignature(sender.generateSignature(sha3.digest()))
    signedTransaction.setRawTxnBytes(rawTransaction.serializeBinary())

    const request = new SubmitTransactionRequest()
    request.setSignedTxn(signedTransaction)
    return new Promise((resolve, reject) => {
      this.client.submitTransaction(request, undefined, (error: any | null, response: SubmitTransactionResponse) => {
        if (error) {
          return reject(error)
        }
        resolve(response)
      })

export function hash256b(input: string | Buffer | Uint8Array): Buffer {
  const k = new Keccak(256);
  // @ts-ignore
  k.update(Buffer.from(input));
  return k.digest();
}

payload.setFee(0);
  const code = Buffer.from(data, 'hex');
  // if we are deploying and it looks like wasm, it must be wasm. Note that
  // evm opcode 0 is stop, so this would not make any sense.
  const wasm_magic = Buffer.from('\0asm');
  if (!address && !Buffer.compare(code.slice(0, 4), wasm_magic)) {
    payload.setWasm(code);
  } else {
    payload.setData(code);
  }
  // If address is null then we are creating a new contract, if we have the deployedBytecode then send it with the ABI
  if (!address && contract.code.deployedBytecode) {
    const meta = new ContractMeta()
    // TODO: document/formalise the expected structure of the contract metadata
    meta.setMeta(JSON.stringify({ Abi: contract.abi }))
    const codeHash = (new Keccak(256)).update(contract.code.deployedBytecode, "hex").digest()
    meta.setCodehash(codeHash)
    payload.setContractmetaList([meta])
  }

  return payload
}

function hash256b(input) {
  const k = new _sha.Keccak(256); // @ts-ignore

  k.update(Buffer.from(input));
  return k.digest();
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jcnlwdG8vaGFzaC50cyJdLCJuYW1lcyI6WyJoYXNoMTYwYiIsImlucHV0IiwiZGlnZXN0IiwiaGFzaDI1NmIiLCJzbGljZSIsImsiLCJLZWNjYWsiLCJ1cGRhdGUiLCJCdWZmZXIiLCJmcm9tIl0sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQUNBOztBQURBO0FBR0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNPLFNBQVNBLFFBQVQsQ0FBa0JDLEtBQWxCLEVBQStEO0FBQ3BFLFFBQU1DLE1BQU0sR0FBR0MsUUFBUSxDQUFDRixLQUFELENBQXZCO0FBQ0EsU0FBT0MsTUFBTSxDQUFDRSxLQUFQLENBQWEsRUFBYixDQUFQO0FBQ0Q7O0FBRU0sU0FBU0QsUUFBVCxDQUFrQkYsS0FBbEIsRUFBK0Q7QUFDcEUsUUFBTUksQ0FBQyxHQUFHLElBQUlDLFdBQUosQ0FBVyxHQUFYLENBQVYsQ0FEb0UsQ0FFcEU7O0FBQ0FELEVBQUFBLENBQUMsQ0FBQ0UsTUFBRixDQUFTQyxNQUFNLENBQUNDLElBQVAsQ0FBWVIsS0FBWixDQUFUO0FBQ0EsU0FBT0ksQ0FBQyxDQUFDSCxNQUFGLEVBQVA7QUFDRCIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1pZ25vcmVcbmltcG9ydCB7IEtlY2NhayB9IGZyb20gXCJzaGEzXCI7XG5cbi8vIENvbXB1dGVzIHRoZSBCTEFLRTJCIGhhc2ggb2YgYSBzdHJpbmcgb3IgYnl0ZSBhcnJheSwgYW5kIHJldHVybnMgYSBVaW50OEFycmF5XG4vL1xuLy8gUmV0dXJucyBhIG4tYnl0ZSBVaW50OEFycmF5XG4vL1xuLy8gUGFyYW1ldGVyczpcbi8vIC0gaW5wdXQgLSB0aGUgaW5wdXQgYnl0ZXMsIGFzIGEgc3RyaW5nLCBCdWZmZXIgb3IgVWludDhBcnJheVxuLy8gLSBrZXkgLSBvcHRpb25hbCBrZXkgVWludDhBcnJheSwgdXAgdG8gNjQgYnl0ZXNcbi8vIC0gb3V0bGVuIC0gb3B0aW9uYWwgb3V0cHV0IGxlbmd0aCBpbiBieXRlcywgZGVmYXVsdCA2NFxuZXhwb3J0IGZ1bmN0aW9uIGhhc2gxNjBiKGlucHV0OiBzdHJpbmcgfCBCdWZmZXIgfCBVaW50OEFycmF5KTogQnVmZmVyIHtcbiAgY29uc3QgZGlnZXN0ID0gaGFzaDI1NmIoaW5wdXQpO1xuICByZXR1cm4gZGlnZXN0LnNsaWNlKDEyKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGhhc2gyNTZiKGlucHV0OiBzdHJpbmcgfCBCdWZmZXIgfCBVaW50OEFycmF5KTogQnVmZmVyIHtcbiAgY29uc3QgayA9IG5ldyBLZWNjYWsoMjU2KTtcbiAgLy8gQHRzLWlnbm9yZVxuICBrLnVwZGF0ZShCdWZmZXIuZnJvbShpbnB1dCkpO1xuICByZXR1cm4gay5kaWdlc3QoKTtcbn1cbiJdfQ==

public DeriveSecretKey(i: number): SecertKeyEx {
        // newKeyRndSeed = Keccak512(chainCode, i, rndSeed).substring(0,96)
        const hash = new Keccak(384); // Keccak 384 has size is 48 bytes
        hash.update(this.chainCode);
        hash.update(i.toString());
        hash.update(this.rndSeed);
        return new SecertKeyEx(hash.digest('hex') + this.chainCode);
    }
}

gethClient.post(codeQueryString, function (codeQueryResponse) {
        responseCounter++;
        var parsedCodeQueryResponse = JSON.parse(codeQueryResponse);
        if (parsedCodeQueryResponse.error) {
          logger.warn('Could not fetch code from geth due to: %s', parsedCodeQueryResponse.error.message);
        } else {
          var code = parsedCodeQueryResponse.result;
          contracts[ind]._source.code = code;
          var sha3 = new SHA3.SHA3Hash(256);
          sha3.update(code, 'ascii');
          contracts[ind]._source.codeHash = sha3.digest('hex').substr(0, 16);
          contracts[ind]._source.codeLength = code.length / 2 - 1;
          // do not update balances!
          delete contracts[ind]._source.balance;
        }

        if (responseCounter === responseCounterTarget) {
          return updateContractCode(contracts, blockNumber, maxBlockNumber);
        }
      });
    })(i, responseCounterTarget, blockNumber, maxBlockNumber, contracts);

function enrichContractData(contract) {
  // see https://github.com/ethereum/pyethereum/blob/782842758e219e40739531a5e56fff6e63ca567b/ethereum/utils.py
  // for contract address calculation
  var sha3 = new SHA3.SHA3Hash(256);
  sha3.update(contract.input, 'ascii');
  contract.inputHash = sha3.digest('hex').substr(0, 16);
  contract.inputLength = contract.input.length / 2 - 1;

  var nonce = contract.nonce;
  // nonce should be hex encoded but not start with '0x'
  if (nonce.substr(0, 2) === '0x') {
    nonce = nonce.substr(2);
  }
  // nonce might have odd length
  if (nonce.length % 2) {
    nonce = '0' + nonce;
  }
  contract.contractAddress = ethUtil.bufferToHex(ethUtil.generateAddress(Buffer.from(contract.from.substr(2), 'hex'), Buffer.from(nonce, 'hex')));

  // delete some unwanted attributes from contract object

});
    program.setArgumentsList(transactionArguments);
    program.setModulesList(transaction.program.modules);
    const rawTransaction = new RawTransaction();
    rawTransaction.setExpirationTime(transaction.expirationTime.toNumber());
    rawTransaction.setGasUnitPrice(transaction.gasContraint.gasUnitPrice.toNumber());
    rawTransaction.setMaxGasAmount(transaction.gasContraint.maxGasAmount.toNumber());
    rawTransaction.setSequenceNumber(sequenceNumber.toNumber());
    rawTransaction.setProgram(program);
    rawTransaction.setSenderAccount(senderAddress.toBytes());

    const signedTransaction = new SignedTransaction();

    const request = new SubmitTransactionRequest();
    const rawTxnBytes = rawTransaction.serializeBinary();
    const hash = new SHA3(256)
      .update(Buffer.from(HashSaltValues.rawTransactionHashSalt, 'hex'))
      .update(Buffer.from(rawTxnBytes.buffer))
      .digest();
    const senderSignature = sender.keyPair.sign(hash);
    signedTransaction.setRawTxnBytes(rawTxnBytes);
    signedTransaction.setSenderPublicKey(sender.keyPair.getPublicKey());
    signedTransaction.setSenderSignature(senderSignature);

    request.setSignedTxn(signedTransaction);
    return new Promise((resolve, reject) => {
      this.client.submitTransaction(request, (error: ServiceError | null, response: SubmitTransactionResponse) => {
        if (error) {
          // TBD: should this fail with only service error
          // or should it fail if transaction is not acknowledged
          return reject(error);
        }

function isValid (input) {
    console.log('is input valid?', input);

    var parts = input.split(':');
    var claim = parts[1];
    
    if (claim < difficulty) {
      return false;
    }
    
    var hash = new crypto.SHA3Hash();
    hash.update(input);
    var digest = hash.digest('hex');
    var match = digest.match(/^(0+)/);
    var bits = (match) ? match[0].length : 0;
    
    if (bits < difficulty) {
      return false;
    }
    
    return true;
  }