bsv-bap 0.0.1 → 0.0.3

package/dist/typescript-npm-package.esm.js

@@ -1,1312 +0,0 @@
-import { Hash, PublicKey, BSM, Utils as Utils$1, ECIES, HD, Signature, BigNumber } from '@bsv/sdk';
-import 'node-fetch';
-import randomBytes from 'randombytes';
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(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());
-    });
-}
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-const Utils = {
-    /**
-     * Helper function for encoding strings to hex
-     *
-     * @param string
-     * @returns {string}
-     */
-    hexEncode(string) {
-        return `0x${Buffer.from(string).toString('hex')}`;
-    },
-    /**
-     * Helper function for encoding strings to hex
-     *
-     * @param hexString string
-     * @param encoding BufferEncoding
-     * @returns {string}
-     */
-    hexDecode(hexString, encoding = 'utf8') {
-        return Buffer.from(hexString.replace('0x', ''), 'hex').toString(encoding);
-    },
-    /**
-     * Helper function to generate a random nonce
-     *
-     * @returns {string}
-     */
-    getRandomString(length = 32) {
-        return randomBytes(length).toString('hex');
-    },
-    /**
-     * Test whether the given string is hex
-     *
-     * @param value any
-     * @returns {boolean}
-     */
-    isHex(value) {
-        if (typeof value !== 'string') {
-            return false;
-        }
-        return /^[0-9a-fA-F]+$/.test(value);
-    },
-    /**
-     * Get a signing path from a hex number
-     *
-     * @param hexString {string}
-     * @param hardened {boolean} Whether to return a hardened path
-     * @returns {string}
-     */
-    getSigningPathFromHex(hexString, hardened = true) {
-        // "m/0/0/1"
-        let signingPath = 'm';
-        const signingHex = hexString.match(/.{1,8}/g);
-        if (!signingHex) {
-            throw new Error('Invalid hex string');
-        }
-        const maxNumber = 2147483648 - 1; // 0x80000000
-        for (const hexNumber of signingHex) {
-            let number = Number(`0x${hexNumber}`);
-            if (number > maxNumber)
-                number -= maxNumber;
-            signingPath += `/${number}${(hardened ? "'" : '')}`;
-        }
-        return signingPath;
-    },
-    /**
-     * Increment that second to last part from the given part, set the last part to 0
-     *
-     * @param path string
-     * @returns {*}
-     */
-    getNextIdentityPath(path) {
-        const pathValues = path.split('/');
-        const secondToLastPart = pathValues[pathValues.length - 2];
-        let hardened = false;
-        if (secondToLastPart.match('\'')) {
-            hardened = true;
-        }
-        const nextPath = (Number(secondToLastPart.replace(/[^0-9]/g, '')) + 1).toString();
-        pathValues[pathValues.length - 2] = nextPath + (hardened ? '\'' : '');
-        pathValues[pathValues.length - 1] = `0${hardened ? '\'' : ''}`;
-        return pathValues.join('/');
-    },
-    /**
-     * Increment that last part of the given path
-     *
-     * @param path string
-     * @returns {*}
-     */
-    getNextPath(path) {
-        const pathValues = path.split('/');
-        const lastPart = pathValues[pathValues.length - 1];
-        let hardened = false;
-        if (lastPart.match('\'')) {
-            hardened = true;
-        }
-        const nextPath = (Number(lastPart.replace(/[^0-9]/g, '')) + 1).toString();
-        pathValues[pathValues.length - 1] = nextPath + (hardened ? '\'' : '');
-        return pathValues.join('/');
-    },
-};
-
-const BAP_BITCOM_ADDRESS = '1BAPSuaPnfGnSBM3GLV9yhxUdYe4vGbdMT';
-const BAP_BITCOM_ADDRESS_HEX = `0x${Buffer.from(BAP_BITCOM_ADDRESS).toString('hex')}`;
-const AIP_BITCOM_ADDRESS = '15PciHG22SNLQJXMoSUaWVi7WSqc7hCfva';
-`0x${Buffer.from(AIP_BITCOM_ADDRESS).toString('hex')}`;
-const BAP_SERVER = 'https://bap.network/api/v1';
-const MAX_INT = 2147483648 - 1; // 0x80000000
-// This is just a choice for this library and could be anything else if so needed/wanted
-// but it is advisable to use the same derivation between libraries for compatibility
-const SIGNING_PATH_PREFIX = 'm/424150\'/0\'/0\''; // BAP in hex
-const ENCRYPTION_PATH = `m/424150'/${MAX_INT}'/${MAX_INT}'`;
-
-var _BAP_ID_HDPrivateKey, _BAP_ID_BAP_SERVER, _BAP_ID_BAP_TOKEN, _BAP_ID_rootPath, _BAP_ID_previousPath, _BAP_ID_currentPath, _BAP_ID_idSeed;
-const { toArray: toArray$1, toHex, toBase58, toUTF8: toUTF8$1, toBase64: toBase64$1 } = Utils$1;
-const { bitcoreDecrypt: bitcoreDecrypt$1, bitcoreEncrypt: bitcoreEncrypt$1 } = ECIES;
-/**
- * BAP_ID class
- *
- * This class should be used in conjunction with the BAP class
- *
- * @type {BAP_ID}
- */
-class BAP_ID {
-    constructor(HDPrivateKey, identityAttributes = {}, idSeed = "") {
-        _BAP_ID_HDPrivateKey.set(this, void 0);
-        _BAP_ID_BAP_SERVER.set(this, BAP_SERVER);
-        _BAP_ID_BAP_TOKEN.set(this, "");
-        _BAP_ID_rootPath.set(this, void 0);
-        _BAP_ID_previousPath.set(this, void 0);
-        _BAP_ID_currentPath.set(this, void 0);
-        _BAP_ID_idSeed.set(this, void 0);
-        __classPrivateFieldSet(this, _BAP_ID_idSeed, idSeed, "f");
-        if (idSeed) {
-            // create a new HDPrivateKey based on the seed
-            const seedHex = toHex(Hash.sha256(idSeed, "utf8"));
-            const seedPath = Utils.getSigningPathFromHex(seedHex);
-            __classPrivateFieldSet(this, _BAP_ID_HDPrivateKey, HDPrivateKey.derive(seedPath), "f");
-        }
-        else {
-            __classPrivateFieldSet(this, _BAP_ID_HDPrivateKey, HDPrivateKey, "f");
-        }
-        this.idName = "ID 1";
-        this.description = "";
-        __classPrivateFieldSet(this, _BAP_ID_rootPath, `${SIGNING_PATH_PREFIX}/0/0/0`, "f");
-        __classPrivateFieldSet(this, _BAP_ID_previousPath, `${SIGNING_PATH_PREFIX}/0/0/0`, "f");
-        __classPrivateFieldSet(this, _BAP_ID_currentPath, `${SIGNING_PATH_PREFIX}/0/0/1`, "f");
-        const rootChild = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(__classPrivateFieldGet(this, _BAP_ID_rootPath, "f"));
-        this.rootAddress = rootChild.privKey.toPublicKey().toAddress();
-        this.identityKey = this.deriveIdentityKey(this.rootAddress);
-        // unlink the object
-        identityAttributes = Object.assign({}, identityAttributes);
-        this.identityAttributes = this.parseAttributes(identityAttributes);
-    }
-    set BAP_SERVER(bapServer) {
-        __classPrivateFieldSet(this, _BAP_ID_BAP_SERVER, bapServer, "f");
-    }
-    get BAP_SERVER() {
-        return __classPrivateFieldGet(this, _BAP_ID_BAP_SERVER, "f");
-    }
-    set BAP_TOKEN(token) {
-        __classPrivateFieldSet(this, _BAP_ID_BAP_TOKEN, token, "f");
-    }
-    get BAP_TOKEN() {
-        return __classPrivateFieldGet(this, _BAP_ID_BAP_TOKEN, "f");
-    }
-    deriveIdentityKey(address) {
-        // base58( ripemd160 ( sha256 ( rootAddress ) ) )
-        const rootAddressHash = toHex(Hash.sha256(address, "utf8"));
-        return toBase58(Hash.ripemd160(rootAddressHash, "hex"));
-    }
-    /**
-     * Helper function to parse identity attributes
-     *
-     * @param identityAttributes
-     * @returns {{}}
-     */
-    parseAttributes(identityAttributes) {
-        if (typeof identityAttributes === "string") {
-            return this.parseStringUrns(identityAttributes);
-        }
-        for (const key in identityAttributes) {
-            if (!identityAttributes[key].value || !identityAttributes[key].nonce) {
-                throw new Error("Invalid identity attribute");
-            }
-        }
-        return identityAttributes || {};
-    }
-    /**
-     * Parse a text of urn string into identity attributes
-     *
-     * urn:bap:id:name:John Doe:e2c6fb4063cc04af58935737eaffc938011dff546d47b7fbb18ed346f8c4d4fa
-     * urn:bap:id:birthday:1990-05-22:e61f23cbbb2284842d77965e2b0e32f0ca890b1894ca4ce652831347ee3596d9
-     * urn:bap:id:over18:1:480ca17ccaacd671b28dc811332525f2f2cd594d8e8e7825de515ce5d52d30e8
-     *
-     * @param urnIdentityAttributes
-     */
-    parseStringUrns(urnIdentityAttributes) {
-        const identityAttributes = {};
-        // avoid forEach
-        const attributesRaw = urnIdentityAttributes
-            .replace(/^\s+/g, "")
-            .replace(/\r/gm, "")
-            .split("\n");
-        for (const line of attributesRaw) {
-            // remove any whitespace from the string (trim)
-            const attribute = line.replace(/^\s+/g, "").replace(/\s+$/g, "");
-            const urn = attribute.split(":");
-            if (urn[0] === "urn" &&
-                urn[1] === "bap" &&
-                urn[2] === "id" &&
-                urn[3] &&
-                urn[4] &&
-                urn[5]) {
-                identityAttributes[urn[3]] = {
-                    value: urn[4],
-                    nonce: urn[5],
-                };
-            }
-        }
-        return identityAttributes;
-    }
-    /**
-     * Returns the identity key
-     *
-     * @returns {*|string}
-     */
-    getIdentityKey() {
-        return this.identityKey;
-    }
-    /**
-     * Returns all the attributes in the identity
-     *
-     * @returns {*}
-     */
-    getAttributes() {
-        return this.identityAttributes;
-    }
-    /**
-     * Get the value of the given attribute
-     *
-     * @param attributeName
-     * @returns {{}|null}
-     */
-    getAttribute(attributeName) {
-        if (this.identityAttributes[attributeName]) {
-            return this.identityAttributes[attributeName];
-        }
-        return null;
-    }
-    /**
-     * Set the value of the given attribute
-     *
-     * If an empty value ('' || null || false) is given, the attribute is removed from the ID
-     *
-     * @param attributeName string
-     * @param attributeValue any
-     * @returns {{}|null}
-     */
-    setAttribute(attributeName, attributeValue) {
-        if (attributeValue) {
-            if (this.identityAttributes[attributeName]) {
-                this.identityAttributes[attributeName].value = attributeValue;
-            }
-            else {
-                this.addAttribute(attributeName, attributeValue);
-            }
-        }
-    }
-    /**
-     * Unset the given attribute from the ID
-     *
-     * @param attributeName
-     * @returns {{}|null}
-     */
-    unsetAttribute(attributeName) {
-        delete this.identityAttributes[attributeName];
-    }
-    /**
-     * Get all attribute urn's for this id
-     *
-     * @returns {string}
-     */
-    getAttributeUrns() {
-        let urns = "";
-        for (const key in this.identityAttributes) {
-            const urn = this.getAttributeUrn(key);
-            if (urn) {
-                urns += `${urn}\n`;
-            }
-        }
-        return urns;
-    }
-    /**
-     * Create an return the attribute urn for the given attribute
-     *
-     * @param attributeName
-     * @returns {string|null}
-     */
-    getAttributeUrn(attributeName) {
-        const attribute = this.identityAttributes[attributeName];
-        if (attribute) {
-            return `urn:bap:id:${attributeName}:${attribute.value}:${attribute.nonce}`;
-        }
-        return null;
-    }
-    /**
-     * Add an attribute to this identity
-     *
-     * @param attributeName
-     * @param value
-     * @param nonce
-     */
-    addAttribute(attributeName, value, nonce = "") {
-        if (!nonce) {
-            nonce = Utils.getRandomString();
-        }
-        this.identityAttributes[attributeName] = {
-            value,
-            nonce,
-        };
-    }
-    /**
-     * This should be called with the last part of the signing path (/.../.../...)
-     * This library assumes the first part is m/424150'/0'/0' as defined at the top of this file
-     *
-     * @param path The second path of the signing path in the format [0-9]{0,9}/[0-9]{0,9}/[0-9]{0,9}
-     */
-    set rootPath(path) {
-        if (__classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f")) {
-            if (path.split("/").length < 5) {
-                path = `${SIGNING_PATH_PREFIX}${path}`;
-            }
-            if (!this.validatePath(path)) {
-                throw new Error(`invalid signing path given ${path}`);
-            }
-            __classPrivateFieldSet(this, _BAP_ID_rootPath, path, "f");
-            const derivedChild = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(path);
-            this.rootAddress = derivedChild.pubKey.toAddress();
-            // Identity keys should be derivatives of the root address - this allows checking
-            // of the creation transaction
-            this.identityKey = this.deriveIdentityKey(this.rootAddress);
-            // we also set this previousPath / currentPath to the root as we seem to be (re)setting this ID
-            __classPrivateFieldSet(this, _BAP_ID_previousPath, path, "f");
-            __classPrivateFieldSet(this, _BAP_ID_currentPath, path, "f");
-        }
-    }
-    get rootPath() {
-        return __classPrivateFieldGet(this, _BAP_ID_rootPath, "f");
-    }
-    getRootPath() {
-        return __classPrivateFieldGet(this, _BAP_ID_rootPath, "f");
-    }
-    /**
-     * This should be called with the last part of the signing path (/.../.../...)
-     * This library assumes the first part is m/424150'/0'/0' as defined at the top of this file
-     *
-     * @param path The second path of the signing path in the format [0-9]{0,9}/[0-9]{0,9}/[0-9]{0,9}
-     */
-    set currentPath(path) {
-        if (path.split("/").length < 5) {
-            path = `${SIGNING_PATH_PREFIX}${path}`;
-        }
-        if (!this.validatePath(path)) {
-            throw new Error("invalid signing path given");
-        }
-        __classPrivateFieldSet(this, _BAP_ID_previousPath, __classPrivateFieldGet(this, _BAP_ID_currentPath, "f"), "f");
-        __classPrivateFieldSet(this, _BAP_ID_currentPath, path, "f");
-    }
-    get currentPath() {
-        return __classPrivateFieldGet(this, _BAP_ID_currentPath, "f");
-    }
-    get previousPath() {
-        return __classPrivateFieldGet(this, _BAP_ID_previousPath, "f");
-    }
-    /**
-     * This can be used to break the deterministic way child keys are created to make it harder for
-     * an attacker to steal the identites when the root key is compromised. This does however require
-     * the seeds to be stored at all times. If the seed is lost, the identity will not be recoverable.
-     */
-    get idSeed() {
-        return __classPrivateFieldGet(this, _BAP_ID_idSeed, "f");
-    }
-    /**
-     * Increment current path to a new path
-     *
-     * @returns {*}
-     */
-    incrementPath() {
-        this.currentPath = Utils.getNextPath(this.currentPath);
-    }
-    /**
-     * Check whether the given path is a valid path for use with this class
-     * The signing paths used here always have a length of 3
-     *
-     * @param path The last part of the signing path (example "/0/0/1")
-     * @returns {boolean}
-     */
-    validatePath(path) {
-        /* eslint-disable max-len */
-        if (path.match(/\/[0-9]{1,10}'?\/[0-9]{1,10}'?\/[0-9]{1,10}'?\/[0-9]{1,10}'?\/[0-9]{1,10}'?\/[0-9]{1,10}'?/)) {
-            const pathValues = path.split("/");
-            if (pathValues.length === 7 &&
-                Number(pathValues[1].replace("'", "")) <= MAX_INT &&
-                Number(pathValues[2].replace("'", "")) <= MAX_INT &&
-                Number(pathValues[3].replace("'", "")) <= MAX_INT &&
-                Number(pathValues[4].replace("'", "")) <= MAX_INT &&
-                Number(pathValues[5].replace("'", "")) <= MAX_INT &&
-                Number(pathValues[6].replace("'", "")) <= MAX_INT) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Get the OP_RETURN for the initial ID transaction (signed with root address)
-     *
-     * @returns {[]}
-     */
-    getInitialIdTransaction() {
-        return this.getIdTransaction(__classPrivateFieldGet(this, _BAP_ID_rootPath, "f"));
-    }
-    /**
-     * Get the OP_RETURN for the ID transaction of the current address / path
-     *
-     * @returns {[]}
-     */
-    getIdTransaction(previousPath = "") {
-        if (__classPrivateFieldGet(this, _BAP_ID_currentPath, "f") === __classPrivateFieldGet(this, _BAP_ID_rootPath, "f")) {
-            throw new Error("Current path equals rootPath. ID was probably not initialized properly");
-        }
-        const opReturn = [
-            Buffer.from(BAP_BITCOM_ADDRESS).toString("hex"),
-            Buffer.from("ID").toString("hex"),
-            Buffer.from(this.identityKey).toString("hex"),
-            Buffer.from(this.getCurrentAddress()).toString("hex"),
-        ];
-        previousPath = previousPath || __classPrivateFieldGet(this, _BAP_ID_previousPath, "f");
-        return this.signOpReturnWithAIP(opReturn, previousPath);
-    }
-    /**
-     * Get address for given path
-     *
-     * @param path
-     * @returns {*}
-     */
-    getAddress(path) {
-        const derivedChild = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(path);
-        return derivedChild.privKey.toPublicKey().toAddress();
-    }
-    /**
-     * Get current signing address
-     *
-     * @returns {*}
-     */
-    getCurrentAddress() {
-        return this.getAddress(__classPrivateFieldGet(this, _BAP_ID_currentPath, "f"));
-    }
-    /**
-     * Get the public key for encrypting data for this identity
-     */
-    getEncryptionPublicKey() {
-        const HDPrivateKey = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(__classPrivateFieldGet(this, _BAP_ID_rootPath, "f"));
-        const encryptionKey = HDPrivateKey.derive(ENCRYPTION_PATH).privKey;
-        // @ts-ignore
-        return encryptionKey.toPublicKey().toString();
-    }
-    /**
-     * Get the public key for encrypting data for this identity, using a seed for the encryption
-     */
-    getEncryptionPublicKeyWithSeed(seed) {
-        const encryptionKey = this.getEncryptionPrivateKeyWithSeed(seed);
-        // @ts-ignore
-        return encryptionKey.toPublicKey().toString("hex");
-    }
-    /**
-     * Encrypt the given string data with the identity encryption key
-     * @param stringData
-     * @param counterPartyPublicKey Optional public key of the counterparty
-     * @return string Base64
-     */
-    encrypt(stringData, counterPartyPublicKey) {
-        const HDPrivateKey = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(__classPrivateFieldGet(this, _BAP_ID_rootPath, "f"));
-        const encryptionKey = HDPrivateKey.derive(ENCRYPTION_PATH).privKey;
-        const publicKey = encryptionKey.toPublicKey();
-        const pubKey = counterPartyPublicKey
-            ? PublicKey.fromString(counterPartyPublicKey)
-            : publicKey;
-        return toBase64$1(bitcoreEncrypt$1(toArray$1(stringData), pubKey));
-    }
-    /**
-     * Decrypt the given ciphertext with the identity encryption key
-     * @param ciphertext
-     * @param counterPartyPublicKey Optional public key of the counterparty
-     */
-    decrypt(ciphertext, counterPartyPublicKey) {
-        const HDPrivateKey = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(__classPrivateFieldGet(this, _BAP_ID_rootPath, "f"));
-        const encryptionKey = HDPrivateKey.derive(ENCRYPTION_PATH).privKey;
-        // const ecies = new ECIES();
-        // if (counterPartyPublicKey) {
-        //   return toUTF8(bitcoreDecrypt(toArray(Buffer.from(ciphertext, 'base64'), 'base64'), encryptionKey))
-        // }
-        // TODO: It seems the counterPartyPublicKey is not being used here
-        return toUTF8$1(bitcoreDecrypt$1(toArray$1(Buffer.from(ciphertext, "base64"), "base64"), encryptionKey));
-        // ecies.privateKey(encryptionKey);
-        // if (counterPartyPublicKey) {
-        //   ecies.publicKey(counterPartyPublicKey);
-        // }
-        // return ecies.decrypt(Buffer.from(ciphertext, 'base64')).toString();
-    }
-    /**
-     * Encrypt the given string data with the identity encryption key
-     * @param stringData
-     * @param seed String seed
-     * @param counterPartyPublicKey Optional public key of the counterparty
-     * @return string Base64
-     */
-    encryptWithSeed(stringData, seed, counterPartyPublicKey) {
-        const encryptionKey = this.getEncryptionPrivateKeyWithSeed(seed);
-        const publicKey = encryptionKey.toPublicKey();
-        // const ecies = new ECIES();
-        if (counterPartyPublicKey) {
-            // ecies.privateKey(encryptionKey);
-            // ecies.publicKey(counterPartyPublicKey);
-            return toBase64$1(bitcoreEncrypt$1(toArray$1(stringData), PublicKey.fromString(counterPartyPublicKey)));
-        }
-        // ecies.publicKey(publicKey);
-        return toBase64$1(bitcoreEncrypt$1(toArray$1(stringData), publicKey));
-        // return ecies.encrypt(stringData).toString('base64');
-    }
-    /**
-     * Decrypt the given ciphertext with the identity encryption key
-     * @param ciphertext
-     * @param seed String seed
-     * @param counterPartyPublicKey Public key of the counterparty
-     */
-    decryptWithSeed(ciphertext, seed, counterPartyPublicKey) {
-        const encryptionKey = this.getEncryptionPrivateKeyWithSeed(seed);
-        // const ecies = new ECIES();
-        // ecies.privateKey(encryptionKey);
-        // if (counterPartyPublicKey) {
-        // ecies.publicKey(counterPartyPublicKey);
-        // TODOL: It seems the counterPartyPublicKey is not being used here
-        return toUTF8$1(bitcoreDecrypt$1(toArray$1(Buffer.from(ciphertext, "base64"), "base64"), encryptionKey));
-        // }
-        // return ecies.decrypt(Buffer.from(ciphertext, 'base64')).toString();
-    }
-    getEncryptionPrivateKeyWithSeed(seed) {
-        const pathHex = toHex(Hash.sha256(seed, "utf8"));
-        const path = Utils.getSigningPathFromHex(pathHex);
-        const HDPrivateKey = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(__classPrivateFieldGet(this, _BAP_ID_rootPath, "f"));
-        return HDPrivateKey.derive(path).privKey;
-    }
-    /**
-     * Get an attestation string for the given urn for this identity
-     *
-     * @param urn
-     * @returns {string}
-     */
-    getAttestation(urn) {
-        const urnHash = Hash.sha256(urn, "utf8");
-        return `bap:attest:${toHex(urnHash)}:${this.getIdentityKey()}`;
-    }
-    /**
-     * Generate and return the attestation hash for the given attribute of this identity
-     *
-     * @param attribute Attribute name (name, email etc.)
-     * @returns {string}
-     */
-    getAttestationHash(attribute) {
-        const urn = this.getAttributeUrn(attribute);
-        if (!urn)
-            return null;
-        const attestation = this.getAttestation(urn);
-        const attestationHash = Hash.sha256(attestation, "utf8");
-        return toHex(attestationHash);
-    }
-    /**
-     * Sign a message with the current signing address of this identity
-     *
-     * @param message
-     * @param signingPath
-     * @returns {{address, signature}}
-     */
-    signMessage(message, signingPath = "") {
-        let msg;
-        if (!(message instanceof Buffer)) {
-            msg = Buffer.from(message);
-        }
-        else {
-            msg = message;
-        }
-        signingPath = signingPath || __classPrivateFieldGet(this, _BAP_ID_currentPath, "f");
-        const childPk = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(signingPath).privKey;
-        const address = childPk.toAddress();
-        const signature = BSM.sign(toArray$1(msg), childPk).toCompact(0, true, "base64");
-        return { address, signature };
-    }
-    /**
-     * Sign a message using a key based on the given string seed
-     *
-     * This works by creating a private key from the root key of this identity. It will always
-     * work with the rootPath / rootKey, to be deterministic. It will not change even if the keys
-     * are rotated for this ID.
-     *
-     * This is used in for instance deterministic login systems, that do not support BAP.
-     *
-     * @param message
-     * @param seed {string} String seed that will be used to generate a path
-     */
-    signMessageWithSeed(message, seed) {
-        const pathHex = toHex(Hash.sha256(seed, "utf8"));
-        const path = Utils.getSigningPathFromHex(pathHex);
-        const HDPrivateKey = __classPrivateFieldGet(this, _BAP_ID_HDPrivateKey, "f").derive(__classPrivateFieldGet(this, _BAP_ID_rootPath, "f"));
-        const derivedChild = HDPrivateKey.derive(path);
-        const address = derivedChild.privKey.toPublicKey().toAddress();
-        const signature = BSM.sign(toArray$1(Buffer.from(message)), derivedChild.privKey).toCompact(0, true, "base64");
-        return { address, signature };
-    }
-    /**
-     * Sign an op_return hex array with AIP
-     * @param opReturn {array}
-     * @param signingPath {string}
-     * @param outputType {string}
-     * @return {[]}
-     */
-    signOpReturnWithAIP(opReturn, signingPath = "", outputType = "hex") {
-        const aipMessageBuffer = this.getAIPMessageBuffer(opReturn);
-        const { address, signature } = this.signMessage(aipMessageBuffer, signingPath);
-        return opReturn.concat([
-            Buffer.from("|").toString(outputType),
-            Buffer.from(AIP_BITCOM_ADDRESS).toString(outputType),
-            Buffer.from("BITCOIN_ECDSA").toString(outputType),
-            Buffer.from(address).toString(outputType),
-            Buffer.from(signature, "base64").toString(outputType),
-        ]);
-    }
-    /**
-     * Construct an AIP buffer from the op return data
-     * @param opReturn
-     * @returns {Buffer}
-     */
-    getAIPMessageBuffer(opReturn) {
-        const buffers = [];
-        if (opReturn[0].replace("0x", "") !== "6a") {
-            // include OP_RETURN in constructing the signature buffer
-            buffers.push(Buffer.from("6a", "hex"));
-        }
-        for (const op of opReturn) {
-            buffers.push(Buffer.from(op.replace("0x", ""), "hex"));
-        }
-        // add a trailing "|" - this is the AIP way
-        buffers.push(Buffer.from("|"));
-        return Buffer.concat([...buffers]);
-    }
-    /**
-     * Get all signing keys for this identity
-     */
-    getIdSigningKeys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const signingKeys = yield this.getApiData("/signing-keys", {
-                idKey: this.identityKey,
-            });
-            console.log("getIdSigningKeys", signingKeys);
-            return signingKeys;
-        });
-    }
-    /**
-     * Get all attestations for the given attribute
-     *
-     * @param attribute
-     */
-    getAttributeAttestations(attribute) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // This function needs to make a call to a BAP server to get all the attestations for this
-            // identity for the given attribute
-            const attestationHash = this.getAttestationHash(attribute);
-            // get all BAP ATTEST records for the given attestationHash
-            const attestations = yield this.getApiData("/attestations", {
-                hash: attestationHash,
-            });
-            console.log("getAttestations", attribute, attestationHash, attestations);
-            return attestations;
-        });
-    }
-    /**
-     * Helper function to get attestation from a BAP API server
-     *
-     * @param apiUrl
-     * @param apiData
-     * @returns {Promise<any>}
-     */
-    getApiData(apiUrl, apiData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const url = `${__classPrivateFieldGet(this, _BAP_ID_BAP_SERVER, "f")}${apiUrl}`;
-            const response = yield fetch(url, {
-                method: "post",
-                headers: {
-                    "Content-type": "application/json; charset=utf-8",
-                    token: __classPrivateFieldGet(this, _BAP_ID_BAP_TOKEN, "f"),
-                    format: "json",
-                },
-                body: JSON.stringify(apiData),
-            });
-            return response.json();
-        });
-    }
-    /**
-     * Import an identity from a JSON object
-     *
-     * @param identity{{}}
-     */
-    import(identity) {
-        this.idName = identity.name;
-        this.description = identity.description || "";
-        this.identityKey = identity.identityKey;
-        __classPrivateFieldSet(this, _BAP_ID_rootPath, identity.rootPath, "f");
-        this.rootAddress = identity.rootAddress;
-        __classPrivateFieldSet(this, _BAP_ID_previousPath, identity.previousPath, "f");
-        __classPrivateFieldSet(this, _BAP_ID_currentPath, identity.currentPath, "f");
-        __classPrivateFieldSet(this, _BAP_ID_idSeed, identity.idSeed || "", "f");
-        this.identityAttributes = this.parseAttributes(identity.identityAttributes);
-    }
-    /**
-     * Export this identity to a JSON object
-     * @returns {{}}
-     */
-    export() {
-        return {
-            name: this.idName,
-            description: this.description,
-            identityKey: this.identityKey,
-            rootPath: __classPrivateFieldGet(this, _BAP_ID_rootPath, "f"),
-            rootAddress: this.rootAddress,
-            previousPath: __classPrivateFieldGet(this, _BAP_ID_previousPath, "f"),
-            currentPath: __classPrivateFieldGet(this, _BAP_ID_currentPath, "f"),
-            idSeed: __classPrivateFieldGet(this, _BAP_ID_idSeed, "f"),
-            identityAttributes: this.getAttributes(),
-            lastIdPath: "",
-        };
-    }
-}
-_BAP_ID_HDPrivateKey = new WeakMap(), _BAP_ID_BAP_SERVER = new WeakMap(), _BAP_ID_BAP_TOKEN = new WeakMap(), _BAP_ID_rootPath = new WeakMap(), _BAP_ID_previousPath = new WeakMap(), _BAP_ID_currentPath = new WeakMap(), _BAP_ID_idSeed = new WeakMap();
-
-var _HDPrivateKey, _ids, _BAP_SERVER, _BAP_TOKEN, _lastIdPath, _a;
-const { toArray, toUTF8, toBase64 } = Utils$1;
-const { bitcoreDecrypt, bitcoreEncrypt } = ECIES;
-/**
- * BAP class
- *
- * Creates an instance of the BAP class and uses the given HDPrivateKey for all BAP operations.
- *
- * @param HDPrivateKey
- */
-const BAP = (_a = class {
-        constructor(HDPrivateKey, token = "") {
-            _HDPrivateKey.set(this, void 0);
-            _ids.set(this, {});
-            _BAP_SERVER.set(this, BAP_SERVER);
-            _BAP_TOKEN.set(this, "");
-            _lastIdPath.set(this, "");
-            if (!HDPrivateKey) {
-                throw new Error("No HDPrivateKey given");
-            }
-            __classPrivateFieldSet(this, _HDPrivateKey, HD.fromString(HDPrivateKey), "f");
-            if (token) {
-                __classPrivateFieldSet(this, _BAP_TOKEN, token, "f");
-            }
-        }
-        get lastIdPath() {
-            return __classPrivateFieldGet(this, _lastIdPath, "f");
-        }
-        /**
-         * Get the public key of the given childPath, or of the current HDPrivateKey of childPath is empty
-         *
-         * @param childPath Full derivation path for this child
-         * @returns {*}
-         */
-        getPublicKey(childPath = "") {
-            if (childPath) {
-                return __classPrivateFieldGet(this, _HDPrivateKey, "f").derive(childPath).pubKey.toString();
-            }
-            return __classPrivateFieldGet(this, _HDPrivateKey, "f").pubKey.toString();
-        }
-        /**
-         * Get the public key of the given childPath, or of the current HDPrivateKey of childPath is empty
-         *
-         * @param childPath Full derivation path for this child
-         * @returns {*}
-         */
-        getHdPublicKey(childPath = "") {
-            if (childPath) {
-                return __classPrivateFieldGet(this, _HDPrivateKey, "f").derive(childPath).toPublic().toString();
-            }
-            return __classPrivateFieldGet(this, _HDPrivateKey, "f").toPublic().toString();
-        }
-        set BAP_SERVER(bapServer) {
-            __classPrivateFieldSet(this, _BAP_SERVER, bapServer, "f");
-            Object.keys(__classPrivateFieldGet(this, _ids, "f")).forEach((key) => {
-                // @ts-ignore - does not recognize private fields that can be set
-                __classPrivateFieldGet(this, _ids, "f")[key].BAP_SERVER = bapServer;
-            });
-        }
-        get BAP_SERVER() {
-            return __classPrivateFieldGet(this, _BAP_SERVER, "f");
-        }
-        set BAP_TOKEN(token) {
-            __classPrivateFieldSet(this, _BAP_TOKEN, token, "f");
-            Object.keys(__classPrivateFieldGet(this, _ids, "f")).forEach((key) => {
-                // @ts-ignore - does not recognize private fields that can be set
-                __classPrivateFieldGet(this, _ids, "f")[key].BAP_TOKEN = token;
-            });
-        }
-        get BAP_TOKEN() {
-            return __classPrivateFieldGet(this, _BAP_TOKEN, "f");
-        }
-        /**
-         * This function verifies that the given bapId matches the given root address
-         * This is used as a data integrity check
-         *
-         * @param bapId BAP_ID instance
-         */
-        checkIdBelongs(bapId) {
-            const derivedChild = __classPrivateFieldGet(this, _HDPrivateKey, "f").derive(bapId.rootPath);
-            const checkRootAddress = derivedChild.pubKey.toAddress();
-            if (checkRootAddress !== bapId.rootAddress) {
-                throw new Error("ID does not belong to this private key");
-            }
-            return true;
-        }
-        /**
-         * Returns a list of all the identity keys that are stored in this instance
-         *
-         * @returns {string[]}
-         */
-        listIds() {
-            return Object.keys(__classPrivateFieldGet(this, _ids, "f"));
-        }
-        /**
-         * Create a new Id and link it to this BAP instance
-         *
-         * This function uses the length of the #ids of this class to determine the next valid path.
-         * If not all ids related to this HDPrivateKey have been loaded, determine the path externally
-         * and pass it to newId when creating a new ID.
-         *
-         * @param path
-         * @param identityAttributes
-         * @param idSeed
-         * @returns {*}
-         */
-        newId(path = "", identityAttributes = {}, idSeed = "") {
-            if (!path) {
-                // get next usable path for this key
-                path = this.getNextValidPath();
-            }
-            const newIdentity = new BAP_ID(__classPrivateFieldGet(this, _HDPrivateKey, "f"), identityAttributes, idSeed);
-            newIdentity.BAP_SERVER = __classPrivateFieldGet(this, _BAP_SERVER, "f");
-            newIdentity.BAP_TOKEN = __classPrivateFieldGet(this, _BAP_TOKEN, "f");
-            newIdentity.rootPath = path;
-            newIdentity.currentPath = Utils.getNextPath(path);
-            const idKey = newIdentity.getIdentityKey();
-            __classPrivateFieldGet(this, _ids, "f")[idKey] = newIdentity;
-            __classPrivateFieldSet(this, _lastIdPath, path, "f");
-            return __classPrivateFieldGet(this, _ids, "f")[idKey];
-        }
-        /**
-         * Remove identity
-         *
-         * @param idKey
-         * @returns {*}
-         */
-        removeId(idKey) {
-            delete __classPrivateFieldGet(this, _ids, "f")[idKey];
-        }
-        /**
-         * Get the next valid path for the used HDPrivateKey and loaded #ids
-         *
-         * @returns {string}
-         */
-        getNextValidPath() {
-            // prefer hardened paths
-            if (__classPrivateFieldGet(this, _lastIdPath, "f")) {
-                return Utils.getNextIdentityPath(__classPrivateFieldGet(this, _lastIdPath, "f"));
-            }
-            return `/0'/${Object.keys(__classPrivateFieldGet(this, _ids, "f")).length}'/0'`;
-        }
-        /**
-         * Get a certain Id
-         *
-         * @param identityKey
-         * @returns {null}
-         */
-        getId(identityKey) {
-            return __classPrivateFieldGet(this, _ids, "f")[identityKey] || null;
-        }
-        /**
-         * This function is used when manipulating ID's, adding or removing attributes etc
-         * First create an id through this class and then use getId to get it. Then you can add/edit or
-         * increment the signing path and then re-set it with this function.
-         *
-         * Note: when you getId() from this class, you will be working on the same object as this class
-         * has and any changes made will be propagated to the id in this class. When you call exportIds
-         * your new changes will also be included, without having to setId().
-         *
-         * @param bapId
-         */
-        setId(bapId) {
-            this.checkIdBelongs(bapId);
-            __classPrivateFieldGet(this, _ids, "f")[bapId.getIdentityKey()] = bapId;
-        }
-        /**
-         * This function is used to import IDs and attributes from some external storage
-         *
-         * The ID information should NOT be stored together with the HD private key !
-         *
-         * @param idData Array of ids that have been exported
-         * @param encrypted Whether the data should be treated as being encrypted (default true)
-         */
-        importIds(idData, encrypted = true) {
-            if (encrypted) {
-                // we first need to decrypt the ids array using ECIES
-                const derivedChild = __classPrivateFieldGet(this, _HDPrivateKey, "f").derive(ENCRYPTION_PATH);
-                const decrypted = toUTF8(bitcoreDecrypt(toArray(Buffer.from(idData, Utils.isHex(idData) ? "hex" : "base64").toString("hex"), "hex"), derivedChild.privKey));
-                idData = JSON.parse(decrypted);
-            }
-            let oldFormatImport = false;
-            if (!idData.ids) {
-                // old format id container
-                oldFormatImport = true;
-                idData = {
-                    lastIdPath: "",
-                    ids: idData,
-                };
-            }
-            for (const id of idData.ids) {
-                if (!id.identityKey || !id.identityAttributes || !id.rootAddress) {
-                    throw new Error("ID cannot be imported as it is not complete");
-                }
-                const importId = new BAP_ID(__classPrivateFieldGet(this, _HDPrivateKey, "f"), {}, id.idSeed);
-                importId.BAP_SERVER = __classPrivateFieldGet(this, _BAP_SERVER, "f");
-                importId.BAP_TOKEN = __classPrivateFieldGet(this, _BAP_TOKEN, "f");
-                importId.import(id);
-                this.checkIdBelongs(importId);
-                __classPrivateFieldGet(this, _ids, "f")[importId.getIdentityKey()] = importId;
-                if (oldFormatImport) {
-                    // overwrite with the last value on this array
-                    idData.lastIdPath = importId.currentPath;
-                }
-            }
-            __classPrivateFieldSet(this, _lastIdPath, idData.lastIdPath, "f");
-        }
-        /**
-         * Export all the IDs of this instance for external storage
-         *
-         * By default this function will encrypt the data, using a derivative child of the main HD key
-         *
-         * @param encrypted Whether the data should be encrypted (default true)
-         * @returns {[]|*}
-         */
-        exportIds(encrypted = true) {
-            const idData = {
-                lastIdPath: __classPrivateFieldGet(this, _lastIdPath, "f"),
-                ids: [],
-            };
-            for (const key of Object.keys(__classPrivateFieldGet(this, _ids, "f"))) {
-                idData.ids.push(__classPrivateFieldGet(this, _ids, "f")[key].export());
-            }
-            if (encrypted) {
-                const derivedChild = __classPrivateFieldGet(this, _HDPrivateKey, "f").derive(ENCRYPTION_PATH);
-                return toBase64(bitcoreEncrypt(toArray(JSON.stringify(idData), 'utf8'), derivedChild.pubKey));
-            }
-            return idData;
-        }
-        /**
-         * Encrypt a string of data
-         *
-         * @param string
-         * @returns {string}
-         */
-        encrypt(string) {
-            const derivedChild = __classPrivateFieldGet(this, _HDPrivateKey, "f").derive(ENCRYPTION_PATH);
-            return toBase64(bitcoreEncrypt(toArray(string, 'utf8'), derivedChild.pubKey));
-        }
-        /**
-         * Decrypt a string of data
-         *
-         * @param string
-         * @returns {string}
-         */
-        decrypt(string) {
-            const derivedChild = __classPrivateFieldGet(this, _HDPrivateKey, "f").derive(ENCRYPTION_PATH);
-            return toUTF8(bitcoreDecrypt(toArray(string, 'base64'), derivedChild.privKey));
-        }
-        /**
-         * Sign an attestation for a user
-         *
-         * @param attestationHash The computed attestation hash for the user - this should be calculated with the BAP_ID class for an identity for the user
-         * @param identityKey The identity key we are using for the signing
-         * @param counter
-         * @param dataString Optional data string that will be appended to the BAP attestation
-         * @returns {string[]}
-         */
-        signAttestationWithAIP(attestationHash, identityKey, counter = 0, dataString = "") {
-            const id = this.getId(identityKey);
-            if (!id) {
-                throw new Error("Could not find identity to attest with");
-            }
-            const attestationBuffer = this.getAttestationBuffer(attestationHash, counter, dataString);
-            const { address, signature } = id.signMessage(attestationBuffer);
-            return this.createAttestationTransaction(attestationHash, counter, address, signature, dataString);
-        }
-        /**
-         * Verify an AIP signed attestation for a user
-         *
-         * [
-         *   '0x6a',
-         *   '0x31424150537561506e66476e53424d33474c56397968785564596534764762644d54',
-         *   '0x415454455354',
-         *   '0x33656166366361396334313936356538353831366439336439643034333136393032376633396661623034386333633031333663343364663635376462383761',
-         *   '0x30',
-         *   '0x7c',
-         *   '0x313550636948473232534e4c514a584d6f5355615756693757537163376843667661',
-         *   '0x424954434f494e5f4543445341',
-         *   '0x31477531796d52567a595557634638776f6f506a7a4a4c764d383550795a64655876',
-         *   '0x20ef60c5555001ddb1039bb0f215e46571fcb39ee46f48b089d1c08b0304dbcb3366d8fdf8bafd82be24b5ac42dcd6a5e96c90705dd42e3ad918b1b47ac3ce6ac2'
-         * ]
-         *
-         * @param tx Array of hex values for the OP_RETURN values
-         * @returns {{}}
-         */
-        verifyAttestationWithAIP(tx) {
-            if (!Array.isArray(tx) ||
-                tx[0] !== "0x6a" ||
-                tx[1] !== BAP_BITCOM_ADDRESS_HEX) {
-                throw new Error("Not a valid BAP transaction");
-            }
-            const dataOffset = tx[7] === "0x44415441" ? 5 : 0; // DATA
-            const attestation = {
-                type: Utils.hexDecode(tx[2]),
-                hash: Utils.hexDecode(tx[3]),
-                sequence: Utils.hexDecode(tx[4]),
-                signingProtocol: Utils.hexDecode(tx[7 + dataOffset]),
-                signingAddress: Utils.hexDecode(tx[8 + dataOffset]),
-                signature: Utils.hexDecode(tx[9 + dataOffset], "base64"),
-            };
-            if (dataOffset && tx[3] === tx[8]) {
-                // valid data addition
-                attestation.data = Utils.hexDecode(tx[9]);
-            }
-            try {
-                const signatureBufferStatements = [];
-                for (let i = 0; i < 6 + dataOffset; i++) {
-                    signatureBufferStatements.push(Buffer.from(tx[i].replace("0x", ""), "hex"));
-                }
-                const attestationBuffer = Buffer.concat([...signatureBufferStatements]);
-                attestation.verified = this.verifySignature(attestationBuffer, attestation.signingAddress, attestation.signature);
-            }
-            catch (e) {
-                attestation.verified = false;
-            }
-            return attestation;
-        }
-        /**
-         * For BAP attestations we use all fields for the attestation
-         *
-         * @param attestationHash
-         * @param counter
-         * @param address
-         * @param signature
-         * @param dataString Optional data string that will be appended to the BAP attestation
-         * @returns {[string]}
-         */
-        createAttestationTransaction(attestationHash, counter, address, signature, dataString = "") {
-            const transaction = ["0x6a", Utils.hexEncode(BAP_BITCOM_ADDRESS)];
-            transaction.push(Utils.hexEncode("ATTEST"));
-            transaction.push(Utils.hexEncode(attestationHash));
-            transaction.push(Utils.hexEncode(`${counter}`));
-            transaction.push("0x7c"); // |
-            if (dataString) {
-                // data should be a string, either encrypted or stringified JSON if applicable
-                transaction.push(Utils.hexEncode(BAP_BITCOM_ADDRESS));
-                transaction.push(Utils.hexEncode("DATA"));
-                transaction.push(Utils.hexEncode(attestationHash));
-                transaction.push(Utils.hexEncode(dataString));
-                transaction.push("0x7c"); // |
-            }
-            transaction.push(Utils.hexEncode(AIP_BITCOM_ADDRESS));
-            transaction.push(Utils.hexEncode("BITCOIN_ECDSA"));
-            transaction.push(Utils.hexEncode(address));
-            transaction.push(`0x${Buffer.from(signature, "base64").toString("hex")}`);
-            return transaction;
-        }
-        /**
-         * This is a re-creation of how the bitcoinfiles-sdk creates a hash to sign for AIP
-         *
-         * @param attestationHash
-         * @param counter
-         * @param dataString Optional data string
-         * @returns {Buffer}
-         */
-        getAttestationBuffer(attestationHash, counter = 0, dataString = "") {
-            // re-create how AIP creates the buffer to sign
-            let dataStringBuffer = Buffer.from("");
-            if (dataString) {
-                dataStringBuffer = Buffer.concat([
-                    Buffer.from(BAP_BITCOM_ADDRESS),
-                    Buffer.from("DATA"),
-                    Buffer.from(attestationHash),
-                    Buffer.from(dataString),
-                    Buffer.from("7c", "hex"),
-                ]);
-            }
-            return Buffer.concat([
-                Buffer.from("6a", "hex"),
-                Buffer.from(BAP_BITCOM_ADDRESS),
-                Buffer.from("ATTEST"),
-                Buffer.from(attestationHash),
-                Buffer.from(`${counter}`),
-                Buffer.from("7c", "hex"),
-                dataStringBuffer,
-            ]);
-        }
-        /**
-         * Verify that the identity challenge is signed by the address
-         *
-         * @param message Buffer or utf-8 string
-         * @param address Bitcoin address of signee
-         * @param signature Signature base64 string
-         *
-         * @return boolean
-         */
-        verifySignature(message, address, signature) {
-            // check the signature against the challenge
-            const messageBuffer = Buffer.isBuffer(message)
-                ? message
-                : Buffer.from(message);
-            const sig = Signature.fromCompact(signature, "base64");
-            let publicKey;
-            const msg = toArray(messageBuffer.toString("hex"), "hex");
-            for (let recovery = 0; recovery < 4; recovery++) {
-                try {
-                    publicKey = sig.RecoverPublicKey(recovery, new BigNumber(BSM.magicHash(msg)));
-                    const sigFitsPubkey = BSM.verify(msg, sig, publicKey);
-                    if (sigFitsPubkey && publicKey.toAddress() === address) {
-                        return true;
-                    }
-                }
-                catch (e) {
-                    // try next recovery
-                }
-            }
-            return false;
-        }
-        /**
-         * Check whether the given transaction (BAP OP_RETURN) is valid, is signed and that the
-         * identity signing is also valid at the time of signing
-         *
-         * @param idKey
-         * @param address
-         * @param challenge
-         * @param signature
-         *
-         * @returns {Promise<boolean|*>}
-         */
-        verifyChallengeSignature(idKey, address, challenge, signature) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // first we test locally before sending to server
-                if (this.verifySignature(challenge, address, signature)) {
-                    const result = yield this.getApiData("/attestation/valid", {
-                        idKey,
-                        challenge,
-                        signature,
-                    });
-                    return result.data;
-                }
-                return false;
-            });
-        }
-        /**
-         * Check whether the given transaction (BAP OP_RETURN) is valid, is signed and that the
-         * identity signing is also valid at the time of signing
-         *
-         * @param tx
-         * @returns {Promise<boolean|*>}
-         */
-        isValidAttestationTransaction(tx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // first we test locally before sending to server
-                if (this.verifyAttestationWithAIP(tx)) {
-                    return this.getApiData("/attestation/valid", {
-                        tx,
-                    });
-                }
-                return false;
-            });
-        }
-        /**
-         * Get all signing keys for the given idKey
-         *
-         * @param address
-         * @returns {Promise<*>}
-         */
-        getIdentityFromAddress(address) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this.getApiData("/identity/from-address", {
-                    address,
-                });
-            });
-        }
-        /**
-         * Get all signing keys for the given idKey
-         *
-         * @param idKey
-         * @returns {Promise<*>}
-         */
-        getIdentity(idKey) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this.getApiData("/identity", {
-                    idKey,
-                });
-            });
-        }
-        /**
-         * Get all attestations for the given attestation hash
-         *
-         * @param attestationHash
-         */
-        getAttestationsForHash(attestationHash) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // get all BAP ATTEST records for the given attestationHash
-                return this.getApiData("/attestations", {
-                    hash: attestationHash,
-                });
-            });
-        }
-        /**
-         * Helper function to get attestation from a BAP API server
-         *
-         * @param apiUrl
-         * @param apiData
-         * @returns {Promise<any>}
-         */
-        getApiData(apiUrl, apiData) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const url = `${__classPrivateFieldGet(this, _BAP_SERVER, "f")}${apiUrl}`;
-                const response = yield fetch(url, {
-                    method: "post",
-                    headers: {
-                        "Content-type": "application/json; charset=utf-8",
-                        token: __classPrivateFieldGet(this, _BAP_TOKEN, "f"),
-                        format: "json",
-                    },
-                    body: JSON.stringify(apiData),
-                });
-                return response.json();
-            });
-        }
-    },
-    _HDPrivateKey = new WeakMap(),
-    _ids = new WeakMap(),
-    _BAP_SERVER = new WeakMap(),
-    _BAP_TOKEN = new WeakMap(),
-    _lastIdPath = new WeakMap(),
-    _a);
-
-export { BAP };
-//# sourceMappingURL=typescript-npm-package.esm.js.map