@gleif-it/vlei-verifier-workflows/dist/cjs/utils/multisig-utils.js

Workflows for vLEI users and vLEI credentials for the vLEI-verifier service

"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 __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.waitAndMarkNotification = exports.startMultisigIncept = exports.multisigRevoke = exports.issueCredentialMultisig = exports.grantMultisig = exports.delegateMultisig = exports.createRegistryMultisig = exports.createAIDMultisig = exports.admitMultisig = exports.addEndRoleMultisig = exports.acceptMultisigIncept = void 0;
const signify_ts_1 = require("signify-ts");
const test_util_js_1 = require("./test-util.js");
function acceptMultisigIncept(client2_1, _a) {
    return __awaiter(this, arguments, void 0, function* (client2, { groupName, localMemberName, msgSaid }) {
        const memberHab = yield client2.identifiers().get(localMemberName);
        const res = yield client2.groups().getRequest(msgSaid);
        const exn = res[0].exn;
        const icp = exn.e.icp;
        const smids = exn.a.smids;
        const rmids = exn.a.rmids;
        const states = yield (0, test_util_js_1.getStates)(client2, smids);
        const rstates = yield (0, test_util_js_1.getStates)(client2, rmids);
        const icpResult2 = yield client2.identifiers().create(groupName, {
            algo: signify_ts_1.default.Algos.group,
            mhab: memberHab,
            isith: icp.kt,
            nsith: icp.nt,
            toad: parseInt(icp.bt),
            wits: icp.b,
            states: states,
            rstates: rstates,
            delpre: icp.di,
        });
        const op2 = yield icpResult2.op();
        const serder = icpResult2.serder;
        const sigs = icpResult2.sigs;
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const ims = signify_ts_1.default.d(signify_ts_1.default.messagize(serder, sigers));
        const atc = ims.substring(serder.size);
        const embeds = {
            icp: [serder, atc],
        };
        const recipients = smids.filter((id) => memberHab.prefix !== id);
        client2
            .exchanges()
            .send(localMemberName, groupName, memberHab, '/multisig/icp', { gid: serder.pre, smids: smids, rmids: smids }, embeds, recipients);
        return op2;
    });
}
exports.acceptMultisigIncept = acceptMultisigIncept;
function addEndRoleMultisig(client_1, groupName_1, aid_1, otherMembersAIDs_1, multisigAID_1, timestamp_1) {
    return __awaiter(this, arguments, void 0, function* (client, groupName, aid, otherMembersAIDs, multisigAID, timestamp, isInitiator = false) {
        if (!isInitiator)
            yield waitAndMarkNotification(client, '/multisig/rpy');
        const opList = [];
        const members = yield client.identifiers().members(multisigAID.name);
        const signings = members['signing'];
        for (const signing of signings) {
            const eid = Object.keys(signing.ends.agent)[0];
            const endRoleResult = yield client
                .identifiers()
                .addEndRole(multisigAID.name, 'agent', eid, timestamp);
            const op = yield endRoleResult.op();
            opList.push(op);
            const rpy = endRoleResult.serder;
            const sigs = endRoleResult.sigs;
            const ghabState1 = multisigAID.state;
            const seal = [
                'SealEvent',
                {
                    i: multisigAID.prefix,
                    s: ghabState1['ee']['s'],
                    d: ghabState1['ee']['d'],
                },
            ];
            const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
            const roleims = signify_ts_1.default.d(signify_ts_1.default.messagize(rpy, sigers, seal, undefined, undefined, false));
            const atc = roleims.substring(rpy.size);
            const roleembeds = {
                rpy: [rpy, atc],
            };
            const recp = otherMembersAIDs.map((aid) => aid.prefix);
            yield client
                .exchanges()
                .send(aid.name, groupName, aid, '/multisig/rpy', { gid: multisigAID.prefix }, roleembeds, recp);
        }
        return opList;
    });
}
exports.addEndRoleMultisig = addEndRoleMultisig;
function admitMultisig(client, aid, otherMembersAIDs, multisigAID, recipientAID, timestamp
// numGrantMsgs: number
) {
    return __awaiter(this, void 0, void 0, function* () {
        const grantMsgSaid = yield waitAndMarkNotification(client, '/exn/ipex/grant');
        const [admit, sigs, end] = yield client.ipex().admit({
            senderName: multisigAID.name,
            message: '',
            grantSaid: grantMsgSaid,
            recipient: recipientAID.prefix,
            datetime: timestamp,
        });
        yield client
            .ipex()
            .submitAdmit(multisigAID.name, admit, sigs, end, [recipientAID.prefix]);
        const mstate = multisigAID.state;
        const seal = [
            'SealEvent',
            { i: multisigAID.prefix, s: mstate['ee']['s'], d: mstate['ee']['d'] },
        ];
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const ims = signify_ts_1.default.d(signify_ts_1.default.messagize(admit, sigers, seal));
        let atc = ims.substring(admit.size);
        atc += end;
        const gembeds = {
            exn: [admit, atc],
        };
        const recp = otherMembersAIDs.map((aid) => aid.prefix);
        yield client
            .exchanges()
            .send(aid.name, 'multisig', aid, '/multisig/exn', { gid: multisigAID.prefix }, gembeds, recp);
    });
}
exports.admitMultisig = admitMultisig;
function createAIDMultisig(client_1, aid_1, otherMembersAIDs_1, groupName_1, kargs_1) {
    return __awaiter(this, arguments, void 0, function* (client, aid, otherMembersAIDs, groupName, kargs, isInitiator = false) {
        var _a;
        if (!isInitiator)
            yield waitAndMarkNotification(client, '/multisig/icp');
        const icpResult = yield client.identifiers().create(groupName, kargs);
        const op = yield icpResult.op();
        const serder = icpResult.serder;
        const sigs = icpResult.sigs;
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const ims = signify_ts_1.default.d(signify_ts_1.default.messagize(serder, sigers));
        const atc = ims.substring(serder.size);
        const embeds = {
            icp: [serder, atc],
        };
        const smids = (_a = kargs.states) === null || _a === void 0 ? void 0 : _a.map((state) => state['i']);
        const recp = otherMembersAIDs.map((aid) => aid.prefix);
        yield client
            .exchanges()
            .send(aid.name, 'multisig', aid, '/multisig/icp', { gid: serder.pre, smids: smids, rmids: smids }, embeds, recp);
        return op;
    });
}
exports.createAIDMultisig = createAIDMultisig;
function createRegistryMultisig(client_1, aid_1, otherMembersAIDs_1, multisigAID_1, registryName_1, nonce_1) {
    return __awaiter(this, arguments, void 0, function* (client, aid, otherMembersAIDs, multisigAID, registryName, nonce, isInitiator = false) {
        if (!isInitiator)
            yield waitAndMarkNotification(client, '/multisig/vcp');
        const vcpResult = yield client.registries().create({
            name: multisigAID.name,
            registryName: registryName,
            nonce: nonce,
        });
        const op = yield vcpResult.op();
        const serder = vcpResult.regser;
        const anc = vcpResult.serder;
        const sigs = vcpResult.sigs;
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const ims = signify_ts_1.default.d(signify_ts_1.default.messagize(anc, sigers));
        const atc = ims.substring(anc.size);
        const regbeds = {
            vcp: [serder, ''],
            anc: [anc, atc],
        };
        const recp = otherMembersAIDs.map((aid) => aid.prefix);
        yield client
            .exchanges()
            .send(aid.name, 'registry', aid, '/multisig/vcp', { gid: multisigAID.prefix }, regbeds, recp);
        return op;
    });
}
exports.createRegistryMultisig = createRegistryMultisig;
function delegateMultisig(client_1, aid_1, otherMembersAIDs_1, multisigAID_1, anchor_1) {
    return __awaiter(this, arguments, void 0, function* (client, aid, otherMembersAIDs, multisigAID, anchor, isInitiator = false) {
        if (!isInitiator) {
            const msgSaid = yield waitAndMarkNotification(client, '/multisig/ixn');
            console.log(`${aid.name}(${aid.prefix}) received exchange message to join the interaction event`);
            const res = yield client.groups().getRequest(msgSaid);
            const exn = res[0].exn;
            const ixn = exn.e.ixn;
            anchor = ixn.a[0];
        }
        // const {delResult, delOp} = await retry(async () => {
        const delResult = yield client
            .delegations()
            .approve(multisigAID.name, anchor);
        const appOp = yield delResult.op();
        console.log(`Delegator ${aid.name}(${aid.prefix}) approved delegation for ${multisigAID.name} with anchor ${JSON.stringify(anchor)}`);
        expect(JSON.stringify(delResult.serder.ked.a[0])).toEqual(JSON.stringify(anchor));
        const serder = delResult.serder;
        const sigs = delResult.sigs;
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const ims = signify_ts_1.default.d(signify_ts_1.default.messagize(serder, sigers));
        const atc = ims.substring(serder.size);
        const xembeds = {
            ixn: [serder, atc],
        };
        const smids = [aid.prefix, ...otherMembersAIDs.map((aid) => aid.prefix)];
        const recp = otherMembersAIDs.map((aid) => aid.prefix);
        yield client
            .exchanges()
            .send(aid.name, multisigAID.name, aid, '/multisig/ixn', { gid: serder.pre, smids: smids, rmids: smids }, xembeds, recp);
        if (isInitiator) {
            console.log(`${aid.name}(${aid.prefix}) initiates delegation interaction event, waiting for others to join...`);
        }
        else {
            console.log(`${aid.name}(${aid.prefix}) joins interaction event`);
        }
        return appOp;
    });
}
exports.delegateMultisig = delegateMultisig;
function grantMultisig(client_1, aid_1, otherMembersAIDs_1, multisigAID_1, recipientAID_1, credential_1, timestamp_1) {
    return __awaiter(this, arguments, void 0, function* (client, aid, otherMembersAIDs, multisigAID, recipientAID, credential, timestamp, isInitiator = false) {
        if (!isInitiator)
            yield waitAndMarkNotification(client, '/multisig/exn');
        const [grant, sigs, end] = yield client.ipex().grant({
            senderName: multisigAID.name,
            acdc: new signify_ts_1.default.Serder(credential.sad),
            anc: new signify_ts_1.default.Serder(credential.anc),
            iss: new signify_ts_1.default.Serder(credential.iss),
            recipient: recipientAID.prefix,
            datetime: timestamp,
        });
        yield client
            .ipex()
            .submitGrant(multisigAID.name, grant, sigs, end, [recipientAID.prefix]);
        const mstate = multisigAID.state;
        const seal = [
            'SealEvent',
            { i: multisigAID.prefix, s: mstate['ee']['s'], d: mstate['ee']['d'] },
        ];
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const gims = signify_ts_1.default.d(signify_ts_1.default.messagize(grant, sigers, seal));
        let atc = gims.substring(grant.size);
        atc += end;
        const gembeds = {
            exn: [grant, atc],
        };
        const recp = otherMembersAIDs.map((aid) => aid.prefix);
        yield client
            .exchanges()
            .send(aid.name, 'multisig', aid, '/multisig/exn', { gid: multisigAID.prefix }, gembeds, recp);
    });
}
exports.grantMultisig = grantMultisig;
function issueCredentialMultisig(client_1, aid_1, otherMembersAIDs_1, multisigAIDName_1, kargsIss_1) {
    return __awaiter(this, arguments, void 0, function* (client, aid, otherMembersAIDs, multisigAIDName, kargsIss, isInitiator = false) {
        var _a, _b, _c;
        if (!isInitiator)
            yield waitAndMarkNotification(client, '/multisig/iss');
        const credResult = yield client
            .credentials()
            .issue(multisigAIDName, kargsIss);
        const op = credResult.op;
        const multisigAID = yield client.identifiers().get(multisigAIDName);
        const keeper = (_b = (_a = client.manager) === null || _a === void 0 ? void 0 : _a.get(multisigAID)) !== null && _b !== void 0 ? _b : undefined;
        const sigs = (_c = (yield (keeper === null || keeper === void 0 ? void 0 : keeper.sign(signify_ts_1.default.b(credResult.anc.raw))))) !== null && _c !== void 0 ? _c : [];
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const ims = signify_ts_1.default.d(signify_ts_1.default.messagize(credResult.anc, sigers));
        const atc = ims.substring(credResult.anc.size);
        const embeds = {
            acdc: [credResult.acdc, ''],
            iss: [credResult.iss, ''],
            anc: [credResult.anc, atc],
        };
        const recp = otherMembersAIDs.map((aid) => aid.prefix);
        yield client
            .exchanges()
            .send(aid.name, 'multisig', aid, '/multisig/iss', { gid: multisigAID.prefix }, embeds, recp);
        return op;
    });
}
exports.issueCredentialMultisig = issueCredentialMultisig;
function multisigRevoke(client, memberName, groupName, rev, anc) {
    return __awaiter(this, void 0, void 0, function* () {
        var _a, _b, _c;
        const leaderHab = yield client.identifiers().get(memberName);
        const groupHab = yield client.identifiers().get(groupName);
        const members = yield client.identifiers().members(groupName);
        const keeper = (_b = (_a = client.manager) === null || _a === void 0 ? void 0 : _a.get(groupHab)) !== null && _b !== void 0 ? _b : undefined;
        const sigs = (_c = (yield (keeper === null || keeper === void 0 ? void 0 : keeper.sign(signify_ts_1.default.b(anc.raw))))) !== null && _c !== void 0 ? _c : [];
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const ims = signify_ts_1.default.d(signify_ts_1.default.messagize(anc, sigers));
        const atc = ims.substring(anc.size);
        const embeds = {
            iss: [rev, ''],
            anc: [anc, atc],
        };
        const recipients = members.signing
            .map((m) => m.aid)
            .filter((aid) => aid !== leaderHab.prefix);
        yield client
            .exchanges()
            .send(memberName, 'multisig', leaderHab, '/multisig/rev', { gid: groupHab.prefix }, embeds, recipients);
    });
}
exports.multisigRevoke = multisigRevoke;
function startMultisigIncept(client, _a) {
    return __awaiter(this, void 0, void 0, function* () {
        var { groupName, localMemberName, participants } = _a, args = __rest(_a, ["groupName", "localMemberName", "participants"]);
        const aid1 = yield client.identifiers().get(localMemberName);
        const participantStates = yield (0, test_util_js_1.getStates)(client, participants);
        const icpResult1 = yield client.identifiers().create(groupName, {
            algo: signify_ts_1.default.Algos.group,
            mhab: aid1,
            isith: args.isith,
            nsith: args.nsith,
            toad: args.toad,
            wits: args.wits,
            delpre: args.delpre,
            states: participantStates,
            rstates: participantStates,
        });
        const op1 = yield icpResult1.op();
        const serder = icpResult1.serder;
        const sigs = icpResult1.sigs;
        const sigers = sigs.map((sig) => new signify_ts_1.default.Siger({ qb64: sig }));
        const ims = signify_ts_1.default.d(signify_ts_1.default.messagize(serder, sigers));
        const atc = ims.substring(serder.size);
        const embeds = {
            icp: [serder, atc],
        };
        const smids = participantStates.map((state) => state['i']);
        yield client
            .exchanges()
            .send(localMemberName, groupName, aid1, '/multisig/icp', { gid: serder.pre, smids: smids, rmids: smids }, embeds, participants);
        return op1;
    });
}
exports.startMultisigIncept = startMultisigIncept;
function waitAndMarkNotification(client, route) {
    return __awaiter(this, void 0, void 0, function* () {
        var _a, _b;
        const notes = yield (0, test_util_js_1.waitForNotifications)(client, route);
        yield Promise.all(notes.map((note) => {
            client.notifications().mark(note.i);
        }));
        return (_b = (_a = notes[notes.length - 1]) === null || _a === void 0 ? void 0 : _a.a.d) !== null && _b !== void 0 ? _b : '';
    });
}
exports.waitAndMarkNotification = waitAndMarkNotification;