@tgrospic/rnode-http-js/dist-module/rev-address.js

HTTP client support for RNode

var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
import { keccak256 } from 'js-sha3';
// @ts-ignore
import blake from 'blakejs';
import { ec } from 'elliptic';
import { decodeBase16, encodeBase58, encodeBase16, decodeBase58safe } from './codecs';
var secp256k1 = new ec('secp256k1');
// Algorithm to generate ETH and REV address is taken from RNode source
// https://github.com/rchain/rchain/blob/bf7a30e1/rholang/src/main/scala/coop/rchain/rholang/interpreter/util/AddressTools.scala#L47
// Prefix as defined in https://github.com/rchain/rchain/blob/c6721a6/rholang/src/main/scala/coop/rchain/rholang/interpreter/util/RevAddress.scala#L13
var prefix = { coinId: "000000", version: "00" };
/**
 * Get REV address from ETH address.
 */
export function getAddrFromEth(ethAddrRaw) {
    var ethAddr = ethAddrRaw.replace(/^0x/, '');
    if (!ethAddr || ethAddr.length !== 40)
        return;
    // Hash ETH address
    var ethAddrBytes = decodeBase16(ethAddr);
    var ethHash = keccak256(ethAddrBytes);
    // Add prefix with hash and calculate checksum (blake2b-256 hash)
    var payload = "" + prefix.coinId + prefix.version + ethHash;
    var payloadBytes = decodeBase16(payload);
    var checksum = blake.blake2bHex(payloadBytes, void 666, 32).slice(0, 8);
    // Return REV address
    return encodeBase58("" + payload + checksum);
}
/**
 * Get REV address (with ETH address) from public key.
 */
export function getAddrFromPublicKey(publicKeyRaw) {
    var publicKey = publicKeyRaw.replace(/^0x/, '');
    if (!publicKey || publicKey.length !== 130)
        return void 666;
    // Public key bytes from hex string
    var pubKeyBytes = decodeBase16(publicKey);
    // Remove one byte from pk bytes and hash
    var pkHash = keccak256(pubKeyBytes.slice(1));
    // Take last 40 chars from hashed pk (ETH address)
    var pkHash40 = pkHash.slice(-40);
    // Return both REV and ETH address
    var revAddr = getAddrFromEth(pkHash40);
    return !!revAddr ? { revAddr: revAddr, ethAddr: pkHash40 } : void 666;
}
/**
 * Get REV address (with ETH address and public key) from private key.
 */
export function getAddrFromPrivateKey(privateKeyRaw) {
    var privateKey = privateKeyRaw.replace(/^0x/, '');
    if (!privateKey || privateKey.length !== 64)
        return;
    // Generate REV address from private key
    var key = secp256k1.keyFromPrivate(privateKey);
    var pubKey = key.getPublic('hex');
    var addr = getAddrFromPublicKey(pubKey);
    // Return public key, REV and ETH address
    return !!addr ? __assign({ pubKey: pubKey }, addr) : void 666;
}
/**
 * Verify REV address
 */
export function verifyRevAddr(revAddr) {
    var revBytes = decodeBase58safe(revAddr);
    if (!revBytes)
        return false;
    // Extract payload and checksum
    var revHex = encodeBase16(revBytes);
    var payload = revHex.slice(0, -8); // without checksum
    var checksum = revHex.slice(-8); // without payload
    // Calculate checksum
    var payloadBytes = decodeBase16(payload);
    var checksumCalc = blake.blake2bHex(payloadBytes, void 666, 32).slice(0, 8);
    return checksum === checksumCalc;
}
/**
 * Generates new private and public key, ETH and REV address.
 */
export function newRevAccount() {
    // Generate new key and REV address from it
    var key = secp256k1.genKeyPair();
    var privKey = key.getPrivate('hex');
    var addr = getAddrFromPrivateKey(privKey);
    // Return public key, REV and ETH address
    return __assign({ privKey: privKey }, addr);
}
/**
 * Creates REV address from different formats
 * (private key -> public key -> ETH address -> REV address)
 */
export function createRevAccount(text) {
    var val = text.replace(/^0x/, '').trim();
    // Account from private key, public key, ETH or REV address
    var fromPriv = getAddrFromPrivateKey(val);
    var fromPub = getAddrFromPublicKey(val);
    var fromEth = getAddrFromEth(val);
    var isRev = verifyRevAddr(val);
    if (isRev) {
        return { revAddr: text };
    }
    else if (!!fromPriv) {
        return __assign({ privKey: val }, fromPriv);
    }
    else if (!!fromPub) {
        return __assign({ pubKey: val }, fromPub);
    }
    else if (!!fromEth) {
        return { privKey: '', pubKey: '', ethAddr: val, revAddr: fromEth };
    }
    else
        return void 666;
}
//# sourceMappingURL=rev-address.js.map