@proyecto-didi/didi-blockchain-manager/dist/BlockchainManager.js

Project to abstract the use of multiblockains in DIDI project

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.BlockchainManager = exports.addPrefix = void 0;
const did_resolver_1 = require("did-resolver");
const web3_1 = __importDefault(require("web3"));
const { Credentials } = require("uport-credentials");
const { createVerifiableCredentialJwt, verifyCredential, } = require("did-jwt-vc");
const DidRegistryContract = require("ethr-did-registry");
const didJWT = require("did-jwt");
const { delegateTypes, getResolver } = require("ethr-did-resolver");
const EthrDID = require("ethr-did");
const blockChainSelector = (networkConfig, did) => {
    let routerCharPos = -1;
    let index = -1;
    let i = 1;
    let searchArray = true;
    const noUportPrefixDid = did.slice(9, did.length);
    routerCharPos = noUportPrefixDid.search(":"); // if routerCharPos > 0 there's another prefix, should search the provider array
    if (routerCharPos === -1) {
        // if not, connect directly to mainnet
        searchArray = false;
        index = 0;
    }
    while (i < networkConfig.length && searchArray) {
        routerCharPos = did.search(networkConfig[i].name);
        if (routerCharPos > 0) {
            index = i; // saves index for connection later
            searchArray = false;
        }
        else {
            i += 1; // provider not found, keep going through array
        }
    }
    const blockchainToConnect = {
        provider: null,
        address: null,
        name: null,
    };
    if (index >= 0) {
        blockchainToConnect.provider = networkConfig[index].rpcUrl;
        blockchainToConnect.address = networkConfig[index].registry;
        blockchainToConnect.name = networkConfig[index].name;
        return blockchainToConnect;
    }
    throw new Error("Invalid Provider Prefix");
};
function addPrefix(prefixToAdd, did) {
    const prefixedDid = did.slice(0, 9) + prefixToAdd + did.slice(9, did.length);
    return prefixedDid;
}
exports.addPrefix = addPrefix;
const checkPrefix = (prefix, networkArray) => {
    let i = 0;
    let notFounded = true;
    while (i < networkArray.length && notFounded) {
        if (prefix === networkArray[i].name) {
            notFounded = false;
        }
        else {
            i += 1;
        }
    }
    return !notFounded;
};
class BlockchainManager {
    constructor(config, gasSafetyValue = 1.2, gasPriceSafetyValue = 1.1) {
        this.config = config;
        this.didResolver = new did_resolver_1.Resolver(getResolver(config.providerConfig));
        this.gasSafetyValue = gasSafetyValue;
        this.gasPriceSafetyValue = gasPriceSafetyValue;
    }
    /**
     * Get the minimum gas price for the given method and options
     * @returns {number}
     */
    getGasPrice(web3) {
        return __awaiter(this, void 0, void 0, function* () {
            const gasPrice = yield web3.eth.getGasPrice();
            const retGasPrice = Math.round(parseInt(gasPrice, 10) * this.gasPriceSafetyValue);
            return retGasPrice;
        });
    }
    /**
     * Get gas limit given the method and options
     * @returns {number}
     */
    getGasLimit(method, options) {
        return __awaiter(this, void 0, void 0, function* () {
            // 21000 is a recommended number
            const gasQty = Math.round(Math.max(yield method.estimateGas(options), 21000) * this.gasSafetyValue);
            return gasQty;
        });
    }
    /**
     * Obtains the ethr-did-registry contract
     * @param options
     * @returns {Contract}
     */
    static getDidContract(options, contractAddress, web3) {
        return new web3.eth.Contract(DidRegistryContract.abi, contractAddress, {
            from: options.from,
        });
    }
    /**
     * Returns the address of the DID
     * @param {string}  did  Did to get the address from
     * @returns {string}
     */
    static getDidAddress(did) {
        const cleanDid = did.split(":");
        return cleanDid[cleanDid.length - 1];
    }
    /**
     *
     * @param {string} did Did to get the blockchain name from
     */
    static getDidBlockchain(did) {
        const didAsArray = did.split(":");
        return didAsArray.length === 4 ? didAsArray[2] : null;
    }
    /**
     * Add a blockchain beofre the ethereum address. Throws if already contains
     * a blockchain. did:ethr:0x123 => did:ethr:rinkeby:0x123
     * @param {string} did Did to add the blockchain
     * @param {string} blockchain Blockchain to add
     */
    static addBlockchainToDid(did, blockchain) {
        const didAsArray = did.split(":");
        if (didAsArray.length === 4)
            throw new Error("#blockchainManager-didWithNetwork");
        didAsArray.splice(2, 0, blockchain);
        return didAsArray.join(":");
    }
    /**
     * Remove netowrk from did. If the did doesn't contain a network, it returns same did
     * did:ethr:net:0x123 => did:ethr:0x123
     * did:ethr:0x123 => did:ethr:0x123
     *
     * @param {string} did DID to remove the network
     */
    static removeBlockchainFromDid(did) {
        const didAsArray = did.split(":");
        if (didAsArray.length === 3)
            return did;
        didAsArray.splice(2, 1);
        return didAsArray.join(":");
    }
    /**
     * Compare two dids DIDs. A DIDI without netowors is equal to a DID with network and
     * same address. Two DIDs with same netork and different address are different. Ex:
     * did:ethr:net:0x123 == did:ethr:0x123
     * did:ethr:net1:0x123 != did:ethr:net2:0x123
     * did:ethr:net:0x123 != did:ethr:net:0x124
     * did:ethr:0x123 != did:ethr:0x124
     * did:ethr:net1:0x123 != did:ethr:net2:0x124
     * @param {string} did1
     * @param {string} did2
     */
    static compareDid(did1, did2) {
        const didAddress1 = BlockchainManager.getDidAddress(did1);
        const didAddress2 = BlockchainManager.getDidAddress(did2);
        const didBlockchain1 = BlockchainManager.getDidBlockchain(did1);
        const didBlockchain2 = BlockchainManager.getDidBlockchain(did2);
        if (didBlockchain1 == null || didBlockchain2 == null) {
            return didAddress1 === didAddress2;
        }
        return didAddress1 === didAddress2 && didBlockchain1 === didBlockchain2;
    }
    /**
     * If syncing throws #blockchainManager-nodeIsSyncing
     * @param web3 web3 instance
     */
    static onlySynced({ eth }) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const isSyncingResponse = yield eth.isSyncing();
                if (isSyncingResponse)
                    throw new Error("#blockchainManager-nodeIsSyncing");
            }
            catch (e) {
                // RSK public node don't allow eth_syncing. We assume that is always in sync
                if (e.message.includes("403 Method Not Allowed")) {
                    return;
                }
                throw e;
            }
        });
    }
    /**
     * Given a network add delegateDID as a delegate of identity
     * @param {NetworkConfig} blockchainToConnect
     * @param {Identity} identity
     * @param {string} delegateDID
     * @param {string} validity
     */
    delegateOnBlockchain(blockchainToConnect, identity, delegateDID, validity) {
        return __awaiter(this, void 0, void 0, function* () {
            const provider = new web3_1.default.providers.HttpProvider(blockchainToConnect.provider);
            const web3 = new web3_1.default(provider);
            yield BlockchainManager.onlySynced(web3);
            const identityAddr = BlockchainManager.getDidAddress(identity.did);
            const delegateAddr = BlockchainManager.getDidAddress(delegateDID);
            const options = {
                from: identityAddr,
            };
            const contract = BlockchainManager.getDidContract(options, blockchainToConnect.address, web3);
            const account = web3.eth.accounts.privateKeyToAccount(identity.privateKey);
            web3.eth.accounts.wallet.add(account);
            const addDelegateMethod = contract.methods.addDelegate(identityAddr, BlockchainManager.delegateType, delegateAddr, validity);
            options.gas = yield this.getGasLimit(addDelegateMethod, options);
            options.gasPrice = yield this.getGasPrice(web3);
            options.nonce =
                blockchainToConnect.name !== "lacchain"
                    ? yield web3.eth.getTransactionCount(identityAddr, "pending")
                    : undefined;
            let delegateMethodSent;
            try {
                delegateMethodSent = yield addDelegateMethod.send(options);
            }
            catch (e) {
                if (BlockchainManager.isUnknownError(e)) {
                    throw e;
                }
                delegateMethodSent = yield this.delegateOnBlockchain(blockchainToConnect, identity, delegateDID, validity);
            }
            web3.eth.accounts.wallet.remove(account.address);
            return delegateMethodSent;
        });
    }
    /**
     * Add delegateDID as a delegate of identity on one or more networks
     * @param {Identity}  identity
     * @param {string}  delegateDID
     * @param {string}  validity
     */
    addDelegate(identity, delegateDID, validity) {
        return __awaiter(this, void 0, void 0, function* () {
            const blockchain = BlockchainManager.getDidBlockchain(delegateDID);
            if (blockchain) {
                const blockchainToConnect = blockChainSelector(this.config.providerConfig.networks, delegateDID);
                const [delegation] = yield Promise.allSettled([
                    this.delegateOnBlockchain(blockchainToConnect, identity, delegateDID, validity),
                ]);
                return [
                    {
                        network: blockchainToConnect.name,
                        status: delegation.status,
                        value: delegation.reason || delegation.value,
                    },
                ];
            }
            const validNetworks = this.config.providerConfig.networks.filter(({ name }) => !!name);
            const delegations = validNetworks
                .map(({ rpcUrl, registry, name }) => ({
                provider: rpcUrl,
                address: registry,
                name,
            }))
                .map((network) => this.delegateOnBlockchain(network, identity, delegateDID, validity));
            // PromiseConstructor.allSettled<any>(values: any) should be an array ,but is a single value
            const settledDelegations = yield Promise.allSettled(delegations);
            return settledDelegations.map((result, index) => (Object.assign({ network: validNetworks[index].name }, result)));
        });
    }
    /**
     * Given a blockchain and an issuer, validate the delegate
     * @param {NetworkConfig} blockchainToConnect
     * @param {String} identityAddr
     * @param {String} delegateAddr
     */
    static validateOnBlockchain(blockchainToConnect, identityAddr, delegateAddr) {
        return __awaiter(this, void 0, void 0, function* () {
            const provider = new web3_1.default.providers.HttpProvider(blockchainToConnect.provider);
            const web3 = new web3_1.default(provider);
            yield BlockchainManager.onlySynced(web3);
            const options = {
                from: identityAddr,
            };
            const contract = BlockchainManager.getDidContract(options, blockchainToConnect.address, web3);
            const validDelegateMethod = contract.methods.validDelegate(identityAddr, BlockchainManager.delegateType, delegateAddr);
            return validDelegateMethod.call(options);
        });
    }
    /**
     * validate if delegateDID is delegate of identityDID
     * @param {Identity}  identityDID
     * @param {string}  delegateDID
     */
    validDelegate(identityDID, delegateDID) {
        return __awaiter(this, void 0, void 0, function* () {
            const identityAddr = BlockchainManager.getDidAddress(identityDID);
            const delegateAddr = BlockchainManager.getDidAddress(delegateDID);
            const blockchain = BlockchainManager.getDidBlockchain(delegateDID);
            if (blockchain) {
                const blockchainToConnect = blockChainSelector(this.config.providerConfig.networks, delegateDID);
                return BlockchainManager.validateOnBlockchain(blockchainToConnect, identityAddr, delegateAddr);
            }
            const validations = this.config.providerConfig.networks.map((network) => {
                const blockchainToConnect = {
                    provider: network.rpcUrl,
                    address: network.registry,
                    name: network.name,
                };
                return BlockchainManager.validateOnBlockchain(blockchainToConnect, identityAddr, delegateAddr);
            });
            const results = yield Promise.allSettled(validations);
            return results.some((result) => result.value === true);
        });
    }
    /**
     * Resolve a DID document
     * @param {string} did DID to resolve its document
     */
    resolveDidDocument(did) {
        return __awaiter(this, void 0, void 0, function* () {
            const resolvedDid = yield this.didResolver.resolve(did);
            return resolvedDid;
        });
    }
    /**
     * Creates a JWT from a base payload with the information to encode
     * @param {string}  issuerDid  Issuer DID
     * @param {object}  payload  Information of the JWT
     * @param {string}  pkey  Information of the PK
     * @param {number}  expiration  Expiration of the JWT in [NumericDate]{@link https://tools.ietf.org/html/rfc7519#section-2}
     * @param {string}  audienceDID  DID of the audience of the JWT
     * @returns {string}  JWT's string
     */
    static createJWT(issuerDid, pkey, payload, expiration = undefined, audienceDID = undefined) {
        return __awaiter(this, void 0, void 0, function* () {
            const signer = didJWT.SimpleSigner(pkey);
            const response = yield didJWT.createJWT(Object.assign(Object.assign({}, payload), { exp: expiration, aud: audienceDID }), { issuer: issuerDid, signer }, { alg: "ES256K-R" });
            return response;
        });
    }
    /**
     * Creates a valid signer
     * @param {string}  privateKey  A hex encoded private key
     * @returns {Signer}  A configured signer function
     */
    static getSigner(privateKey) {
        return didJWT.SimpleSigner(privateKey);
    }
    /**
     * Verify a JWT string with the given audience
     * @param {string} jwt JWT to be verified
     * @param {string} audienceDID DID of the audience if needed
     */
    verifyJWT(jwt, audienceDID = undefined) {
        return __awaiter(this, void 0, void 0, function* () {
            const response = yield didJWT.verifyJWT(jwt, {
                resolver: this.didResolver,
                audience: audienceDID,
            });
            response.doc = response.didResolutionResult.didDocument;
            return response;
        });
    }
    /**
     * Waring: Use verifyJWT. Decodes a token and returns the contet.
     * @param {string}  jwt
     */
    static decodeJWT(jwt) {
        return __awaiter(this, void 0, void 0, function* () {
            return didJWT.decodeJWT(jwt);
        });
    }
    /**
     * genera un certificado asociando la informacion recibida en "subject" con el did
     * @param {string} subjectDid This did has this prefix always (did:ethr:) it doesn't change
     * @param {string} subjectPayload
     * @param {Date} expirationDate
     * @param {string} issuerDid The issuer might change and has different prefixes
     * @param {string} issuerPkey
     */
    static createCredential(subjectDid, subjectPayload, expirationDate, issuerDid, issuerPkey) {
        return __awaiter(this, void 0, void 0, function* () {
            const cleanDid = issuerDid.split(":");
            const prefixedDid = cleanDid.slice(2).join(":");
            const vcIssuer = new EthrDID({
                address: prefixedDid,
                privateKey: issuerPkey,
            });
            const date = expirationDate
                ? Math.floor(new Date(expirationDate).getTime() / 1000 || 0)
                : undefined;
            const vcPayload = {
                sub: subjectDid,
                vc: {
                    "@context": ["https://www.w3.org/2018/credentials/v1"],
                    type: ["VerifiableCredential"],
                    credentialSubject: subjectPayload,
                },
                exp: date,
            };
            const result = yield createVerifiableCredentialJwt(vcPayload, vcIssuer);
            return result;
        });
    }
    /**
     * Verifies a credential using the universal resolver and verifies issuer
     * @param {string} jwt Credential encoded as jwt
     * @param {string} IdentityDid  Central entity DID, usually DIDI
     */
    verifyCredential(jwt, IdentityDid) {
        return __awaiter(this, void 0, void 0, function* () {
            const credentialVerification = verifyCredential(jwt, this.didResolver);
            if (!IdentityDid)
                return credentialVerification;
            const isIssuerValid = this.validDelegate(IdentityDid, credentialVerification.issuer);
            return Object.assign({ isIssuerValid }, credentialVerification);
        });
    }
    /**
     * Given an prefix, genereates new privte and public keys.
     * @param {string}  prefixToAdd
     */
    createIdentity(prefixToAdd = "") {
        let prefixChecked = false;
        let prefixedDid = null;
        if (prefixToAdd) {
            prefixChecked = checkPrefix(prefixToAdd, this.config.providerConfig.networks);
            if (!prefixChecked) {
                throw new Error("Invalid Prefix - Check Provider Network Configuration");
            }
        }
        const credential = Credentials.createIdentity();
        if (prefixToAdd) {
            prefixedDid = addPrefix(`${prefixToAdd}:`, credential.did);
            credential.did = prefixedDid;
        }
        return credential;
    }
    /**
     * Given a blockchain revoke a delegate
     * @param {NetworkConfig} blockchainToConnect
     * @param {string} delegatedDID
     * @param {Identity} issuerCredentials
     */
    revokeOnBlockchain(blockchainToConnect, delegatedDID, issuerCredentials) {
        return __awaiter(this, void 0, void 0, function* () {
            const sourceAddress = BlockchainManager.getDidAddress(issuerCredentials.did);
            const targetAddress = BlockchainManager.getDidAddress(delegatedDID);
            const provider = new web3_1.default.providers.HttpProvider(blockchainToConnect.provider);
            const web3 = new web3_1.default(provider);
            const options = { from: sourceAddress };
            const contract = BlockchainManager.getDidContract(options, blockchainToConnect.address, web3);
            const account = web3.eth.accounts.privateKeyToAccount(issuerCredentials.privateKey);
            web3.eth.accounts.wallet.add(account);
            const revokeDelegateMethod = contract.methods.revokeDelegate(sourceAddress, BlockchainManager.delegateType, targetAddress);
            options.gas = yield this.getGasLimit(revokeDelegateMethod, options);
            options.gasPrice = yield this.getGasPrice(web3);
            options.nonce =
                blockchainToConnect.name !== "lacchain"
                    ? yield web3.eth.getTransactionCount(sourceAddress, "pending")
                    : undefined;
            let revokeMethodSent;
            try {
                revokeMethodSent = yield revokeDelegateMethod.send(options);
            }
            catch (e) {
                if (BlockchainManager.isUnknownError(e)) {
                    throw e;
                }
                revokeMethodSent = yield this.revokeDelegate(issuerCredentials, delegatedDID);
            }
            web3.eth.accounts.wallet.remove(account.address);
            return revokeMethodSent;
        });
    }
    /**
     * Revoke delegation
     * @param {Identity}  issuerCredentials
     * @param {string}  delegatedDID
     */
    revokeDelegate(issuerCredentials, delegatedDID) {
        return __awaiter(this, void 0, void 0, function* () {
            const blockchain = BlockchainManager.getDidBlockchain(delegatedDID);
            if (blockchain) {
                const blockchainToConnect = blockChainSelector(this.config.providerConfig.networks, delegatedDID);
                const revoke = yield Promise.allSettled([
                    this.revokeOnBlockchain(blockchainToConnect, delegatedDID, issuerCredentials),
                ]);
                return [
                    {
                        network: blockchainToConnect.name,
                        status: revoke[0].status,
                        value: revoke[0].reason || revoke[0].value,
                    },
                ];
            }
            const validNetworks = this.config.providerConfig.networks.filter(({ name }) => !!name);
            const delegations = validNetworks
                .map(({ rpcUrl, registry, name }) => ({
                provider: rpcUrl,
                address: registry,
                name,
            }))
                .map((network) => this.revokeOnBlockchain(network, delegatedDID, issuerCredentials));
            // PromiseConstructor.allSettled<any>(values: any) should be an array ,but is a single value
            const settledDelegations = yield Promise.allSettled(delegations);
            return settledDelegations.map((result, index) => (Object.assign({ network: validNetworks[index].name }, result)));
        });
    }
    /**
     * We dont want to bump txs. This only happen if simultaneous tx are sent, this resend recursively
     * the tx increasing nonce by one
     * @param error
     */
    static isUnknownError(error) {
        return !(error.message.includes("gas price not enough to bump transaction") ||
            error.message.includes("transaction underpriced") ||
            error.message.includes("too low") ||
            error.message.includes("too high"));
    }
}
exports.BlockchainManager = BlockchainManager;
BlockchainManager.delegateType = delegateTypes.Secp256k1SignatureAuthentication2018;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BlockchainManager.js","sourceRoot":"","sources":["../src/BlockchainManager.ts"],"names":[],"mappings":"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"}