@agentunion/fastaun 0.5.19 → 0.5.21

package/dist/facades.js

@@ -1,9 +1,320 @@
 import { GroupFSVFS } from './group-fs.js';
 import { GROUP_INDEX_KEY, groupIndexSettingEtag, parseGroupIndex, prepareGroupSettingsWithIndex, verifyGroupIndex, } from './group-index.js';
-import { certMatchesFingerprint } from './cert-utils.js';
-import { createCredential, createMemberCredential, createMembershipBinding, signMembershipBinding, prepareOrganizationRequest, signTransferAcceptance, verifyCredential, verifyCredentialSignature, verifyRegistrationReceipt } from './org-protocol.js';
+import { certMatchesFingerprint, publicKeyCurve, publicKeyDerB64 } from './cert-utils.js';
+import { isJsonObject } from './types.js';
+import { ValidationError } from './errors.js';
+import { digest, createCredential, createMemberCredential, createMembershipBinding, signMembershipBinding, prepareOrganizationRequest, signTransferAcceptance, verifyCredential, verifyCredentialSignature, verifyRegistrationReceipt } from './org-protocol.js';
 import { normalizeGroupId } from './group-id.js';
 import { validateAIDFormat, validateGroupIDFormat } from './validators.js';
+export class DebugFacade {
+    client;
+    withTrace;
+    tail = Promise.resolve();
+    constructor(client, withTrace) {
+        this.client = client;
+        this.withTrace = withTrace;
+    }
+    async diag(scope = '') {
+        if (scope !== null && typeof scope !== 'string')
+            throw new ValidationError('诊断 scope 必须是字符串');
+        const selected = ((scope ?? '').trim() || '*').replace(/\.\*$/, '');
+        const namespaceScope = (scope ?? '').trim().endsWith('.*');
+        const aid = this.client.aid ?? '';
+        const report = { scope: selected, aid, passed: 0, failed: 0, skipped: 0, checks: [] };
+        if (selected === 'debug' || selected.startsWith('debug.')) {
+            report.usage = 'client.debug.diag(scope=""): 空或 * 检查全部；namespace 或 namespace.* 检查命名空间；完整 RPC 名精确匹配；debug 显示本说明。所有服务检查均为 dry-run，不执行业务处理器。';
+            return report;
+        }
+        if (!aid)
+            throw new ValidationError('诊断需要当前客户端的 AID');
+        const operation = this.tail.then(() => this.withTrace(() => this.run(report, namespaceScope)));
+        this.tail = operation.catch(() => undefined);
+        return operation;
+    }
+    async run(report, namespaceScope) {
+        const directoryStarted = Date.now();
+        let methods;
+        try {
+            const listing = await this.client.call('debug.diag', { dry_run: true, action: 'list' });
+            if (!isJsonObject(listing) || listing.dry_run !== true || listing.executed !== false
+                || !Array.isArray(listing.methods) || listing.methods.some((method) => typeof method !== 'string' || !method.trim())) {
+                throw new ValidationError('服务端未确认诊断目录为 dry-run');
+            }
+            methods = [...new Set(listing.methods)];
+        }
+        catch (error) {
+            report.checks.push(this.failure('debug.diag', directoryStarted, error));
+            report.failed++;
+            return report;
+        }
+        let selected = report.scope === '*' ? methods.filter((method) => !method.startsWith('debug.')) : methods.includes(report.scope) ? [report.scope]
+            : methods.filter((method) => method.startsWith(report.scope + '.'));
+        if (selected.length === 0 && report.scope !== '*') {
+            if (report.scope.includes('.') && !namespaceScope)
+                selected = [report.scope];
+            else
+                throw new ValidationError(`当前服务未声明该 scope: ${report.scope}`, { data: { stage: 'gateway.catalog' } });
+        }
+        const runId = `diag-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+        for (const method of selected) {
+            for (const fixture of this.scenarios(method, report.aid, runId)) {
+                const scenario = fixture.scenario;
+                if (fixture.reason) {
+                    report.checks.push({ method, scenario, status: 'skipped', duration_ms: 0, reason: fixture.reason, stage: 'sdk.fixture' });
+                    report.skipped++;
+                    continue;
+                }
+                const started = Date.now();
+                try {
+                    const result = await this.client.call('debug.diag', { dry_run: true, method, params: fixture.params });
+                    if (!isJsonObject(result) || result.dry_run !== true || result.executed !== false || result.method !== method
+                        || !Array.isArray(result.stages) || result.stages.length === 0
+                        || result.stages.some((stage) => !isJsonObject(stage) || typeof stage.stage !== 'string' || !stage.stage.trim()
+                            || (stage.status !== 'passed' && stage.status !== 'skipped'))) {
+                        throw new ValidationError('服务端未确认该 RPC 为 dry-run 且未执行');
+                    }
+                    if (result.status === 'skipped') {
+                        report.checks.push({ method, scenario, status: 'skipped', duration_ms: Date.now() - started, result,
+                            reason: typeof result.reason === 'string' && result.reason ? result.reason : '服务端跳过该 dry-run 检查' });
+                        report.skipped++;
+                    }
+                    else {
+                        report.checks.push({ method, scenario, status: 'passed', duration_ms: Date.now() - started, result });
+                        report.passed++;
+                    }
+                }
+                catch (error) {
+                    report.checks.push({ ...this.failure(method, started, error), scenario });
+                    report.failed++;
+                }
+            }
+        }
+        return report;
+    }
+    failure(method, started, error) {
+        const check = { method, status: 'failed', duration_ms: Date.now() - started, error: error instanceof Error ? error.message : String(error) };
+        const data = error?.data;
+        if (data !== undefined && data !== null)
+            check.data = data;
+        if (isJsonObject(data) && typeof data.stage === 'string')
+            check.stage = data.stage;
+        return check;
+    }
+    scenarios(method, aid, runId) {
+        const base = this.params(method, aid, runId);
+        const cases = (entries) => Object.entries(entries).map(([scenario, params]) => ({ scenario, params: { ...base, ...params } }));
+        if (['auth.aid_login1', 'auth.request_cert', 'ca.verify_chain'].includes(method)) {
+            const cert = this.client.currentAid?.certPem ?? '';
+            if (!cert)
+                return [{ scenario: 'fixture_unavailable', reason: '当前客户端内存没有可用的真实身份证书' }];
+            if (method === 'auth.aid_login1')
+                return [{ scenario: 'existing_certificate', params: { aid, cert, client_nonce: runId } }];
+            if (method === 'ca.verify_chain')
+                return [{ scenario: 'existing_certificate', params: { aid, cert_pem: cert } }];
+            const curve = publicKeyCurve(cert);
+            const publicKey = curve ? publicKeyDerB64(cert) : '';
+            return curve && publicKey ? [{ scenario: 'existing_public_key', params: { aid, public_key: publicKey, curve } }]
+                : [{ scenario: 'fixture_unavailable', reason: '当前内存证书无法提供可用公钥及曲线' }];
+        }
+        if (method === 'message.thought.put' || method === 'message.thought.get') {
+            return [{ scenario: 'self_unsupported', reason: '业务不支持向自身读写私聊 thought，诊断仅允许使用自身 AID' }];
+        }
+        if (method === 'message.peers')
+            return [{ scenario: 'peer_capability', reason: '需要服务端可信协商的 peer pull 能力及设备上下文' }];
+        if (['auth.verify', 'message.v2.send', 'group.v2.send', 'message.v2.put_peer_pk', 'group.v2.put_group_pk', 'group.v2.propose_state', 'group.v2.confirm_state'].includes(method)
+            || (method.startsWith('auth.') && (method.includes('login') || /renew|rekey|create_aid/.test(method)))
+            || method.endsWith('.verify_chain')) {
+            return [{ scenario: 'fixture_unavailable', reason: '缺少该场景所需的真实证书、签名、凭证或密钥材料，不伪造诊断材料' }];
+        }
+        if (method === 'message.send' || method === 'group.send') {
+            return cases({
+                echo: { payload: { type: 'echo', text: 'echo diag' } },
+                text: { payload: { type: 'echo', text: 'echo hello' } },
+                unicode: { payload: { type: 'echo', text: 'echo 诊断 🌍' } },
+            });
+        }
+        if (method === 'message.pull' || method === 'message.v2.pull') {
+            delete base.sender_aid;
+            return cases({
+                tail: { cursor_scope: 'global', window_mode: 'tail', after_seq: 0, limit: 1 },
+                page: { cursor_scope: 'global', after_seq: 0, limit: 10 },
+            });
+        }
+        if (method === 'group.pull' || method === 'group.v2.pull')
+            return cases({ tail: { after_seq: 0, window_mode: 'tail', limit: 1 }, page: { after_seq: 0, limit: 10 } });
+        if (method === 'message.history' || method === 'group.history')
+            return cases({ latest: { before_seq: 1, limit: 1 }, page: { before_seq: 1, limit: 10 } });
+        if (method === 'push.register')
+            return [
+                { scenario: 'basic', params: { push_server_aid: aid, push_token: 'echo' } },
+                { scenario: 'provider', params: { push_server_aid: aid, push_token: 'echo', provider: 'mock', app_id: 'diag' } },
+            ];
+        if (method === 'push.unregister')
+            return [{ scenario: 'default', params: {} }];
+        if (method === 'push.ack')
+            return ['accepted', 'retryable_failure', 'permanent_failure'].map((status) => ({
+                scenario: status, params: { batch_id: '0'.repeat(64), status },
+            }));
+        if (method === 'stream.create')
+            return cases({
+                plain: { metadata: { diag: runId } }, unicode: { metadata: { diag: runId, label: '诊断 🌍' } },
+            });
+        if (method === 'mail.send')
+            return cases({
+                plain: {}, ccbcc: { cc: [aid], bcc: [aid] },
+                attachment: { attachments: [{ filename: 'diag.txt', content_type: 'text/plain', content_b64: 'ZWNobw==', size_bytes: 4, disposition: 'attachment' }] },
+            });
+        if (method === 'mail.list')
+            return cases({
+                first_page: { mailbox: 'inbox', limit: 1 }, offset: { mailbox: 'inbox', limit: 10, offset: 1 },
+                cursor: { mailbox: 'inbox', limit: 1, cursor: 'eyJjcmVhdGVkX2F0IjoxLCJtZXNzYWdlX2lkIjoiZGlhZyJ9' },
+            });
+        if (method === 'mail.search')
+            return cases({ query: { query: 'diag', limit: 1 }, page: { query: 'diag', mailbox: 'inbox', limit: 10, offset: 1 } });
+        if (method === 'mail.mark')
+            return cases({ set_flags: { flags: { seen: true, flagged: true } }, clear_flags: { flags: { seen: false, flagged: false } } });
+        if (['storage.list_objects', 'storage.list_prefixes', 'group.list', 'group.get_members'].includes(method)) {
+            if (method === 'storage.list_prefixes' || method === 'group.list') {
+                return cases({ first_page: { size: 1 }, page_size: { size: 10 } });
+            }
+            return cases({ first_page: { page: 1, size: 1 }, page: { page: 2, size: 10 } });
+        }
+        if (method === 'storage.put_object' || method === 'storage.append_object')
+            return cases({
+                text: {}, unicode: { content: 'ZWNobyDor4rmlq0g8J+MjQ==', size_bytes: 16, sha256: '706dee1332856717aaa230a787a0dd496aa27661f7a6b03c5b8d6eda3b1ca3e1' },
+            });
+        return [{ scenario: 'default', params: base }];
+    }
+    params(method, aid, runId) {
+        if (method === 'org.lifecycle.create')
+            return {
+                org_id: aid, name: 'diag', exttype: 'company', join_mode: 'application', visibility: 'public',
+                owner_aid: aid, request_id: runId, nonce: runId, aad: { org_id: aid },
+            };
+        const params = { aid };
+        if (method.startsWith('message.') || method.startsWith('group.')) {
+            Object.assign(params, {
+                to: aid, peer_aid: aid, sender_aid: aid, aids: [aid], message_id: runId, message_ids: [runId],
+                encrypt: false, context: { type: 'run', id: runId }, payload: { type: 'echo', text: 'echo diag' },
+            });
+        }
+        if (method.startsWith('group.')) {
+            Object.assign(params, {
+                group_id: `${runId}.${aid.slice(aid.indexOf('.') + 1)}`, requester_aid: aid, sender_aid: aid, to: aid,
+                context: { type: 'run', id: runId }, payload: { type: 'echo', text: 'echo diag' }, encrypt: false,
+            });
+        }
+        else if (method.startsWith('storage.')) {
+            Object.assign(params, { owner_aid: aid, bucket: 'default', object_key: runId + '/echo.txt', path: runId + '/echo.txt' });
+        }
+        else if (method.startsWith('stream.')) {
+            Object.assign(params, { target_aid: aid, stream_id: runId, content_type: 'text/plain' });
+        }
+        else if (method.startsWith('mail.')) {
+            params.message_id = runId;
+            if (method === 'mail.send')
+                Object.assign(params, { to: [aid], subject: 'AUN diag', body_text: 'echo' });
+            if (['mail.get', 'mail.delete', 'mail.mark', 'mail.move', 'mail.get_attachment'].includes(method))
+                params.message_id = runId;
+            if (method === 'mail.move')
+                params.to_mailbox = 'archive';
+            if (method === 'mail.get_attachment')
+                params.attachment_id = 1;
+            if (method === 'mail.list')
+                Object.assign(params, { mailbox: 'inbox', limit: 1 });
+            if (method === 'mail.search')
+                Object.assign(params, { query: 'diag', limit: 1 });
+        }
+        if (method === 'proxy.register_services')
+            params.services = [{ service_name: 'diag', service_type: 'http', visibility: 'private' }];
+        if (method === 'event.subscribe' || method === 'event.unsubscribe')
+            params.events = ['message.received', 'group.message_created', 'read_changed'];
+        if (method === 'proxy.unregister_services')
+            params.service_names = ['diag'];
+        if (method.startsWith('auth.'))
+            Object.assign(params, { all: true, token: runId, refresh_token: runId, cert_sn: 'root' });
+        if (method.startsWith('ca.'))
+            params.cert_serial = '0';
+        if (method === 'ca.ct_get_entry')
+            params.log_id = runId;
+        if (method.startsWith('credential.'))
+            Object.assign(params, {
+                request_id: runId, nonce: runId, registrar_aid: aid, credential_cid: runId, reason_code: 'request_failed', include_chain: true, limit: 1,
+            });
+        if (method === 'credential.revoke')
+            Object.assign(params, { cascade: true, reason: 'diag' });
+        if (method === 'credential.revocationList')
+            params.cursor = '0';
+        if (method.startsWith('org.')) {
+            Object.assign(params, {
+                org_id: aid, member_aid: aid, owner_aid: aid, target_member_aid: aid, targets: [aid], aad: { org_id: aid },
+                expected_version: 1, page: 1, size: 1, request_id: runId, nonce: runId, join_request_id: runId, invite_id: runId,
+            });
+            if (method.endsWith('.update'))
+                params.patch = { name: 'diag' };
+            if (method.endsWith('.offboard'))
+                params.action = 'cancel';
+            if (method.endsWith('.ban'))
+                params.duration = 1;
+            if (method === 'org.authz.check')
+                params.target_method = 'org.member.get';
+            if (method === 'org.audit.query')
+                Object.assign(params, { limit: 1, fields: ['event_id'] });
+            if (method.startsWith('org.membership.'))
+                Object.assign(params, { membership_id: runId, slot_request_id: runId });
+            if (method === 'org.credential.getStatus')
+                params.credential_cid = runId;
+            if (method === 'org.lifecycle.transfer')
+                params.expires_at = Math.floor(Date.now() / 1000) + 300;
+            if (method === 'org.lifecycle.transferAccept' || method === 'org.lifecycle.transfer_accept')
+                Object.assign(params, { transfer_id: runId, stage: 'finalize' });
+        }
+        if (method.startsWith('message.') || method.startsWith('group.')) {
+            Object.assign(params, { before_seq: 1, after_seq: 0, limit: 1, up_to_seq: 1, msg_seq: 1 });
+            if (method.startsWith('message.')) {
+                Object.assign(params, { cursor_scope: 'global', member_aids: [aid] });
+                if (['message.pull', 'message.v2.pull', 'message.ack', 'message.v2.ack', 'message.history'].includes(method))
+                    delete params.sender_aid;
+            }
+            if (method.endsWith('.read')) {
+                const state = { scope: method.startsWith('group.') ? 'group' : 'p2p', topic_key: runId, last_read_message_id: runId };
+                if (method.startsWith('group.'))
+                    state.group_id = params.group_id;
+                params.states = [state];
+            }
+            if (method.endsWith('.read_state'))
+                Object.assign(params, { scope: method.startsWith('group.') ? 'group' : 'p2p', topic_key: runId });
+            if (method === 'group.set_settings')
+                params.settings = {};
+            if (method === 'group.update')
+                params.metadata = {};
+            if (method === 'group.ack_events')
+                Object.assign(params, { event_seq: 1, up_to_event_seq: 1 });
+            if (method.startsWith('group.fs.')) {
+                const path = aid + ':/groupdata/' + runId;
+                Object.assign(params, { path, src: path, dst: path + '-copy', grantee_aid: 'role:member', perms: 'rw', visibility: 'private' });
+            }
+        }
+        if (method.startsWith('storage.')) {
+            const path = runId + '/echo.txt';
+            Object.assign(params, {
+                content: 'ZWNobw==', size_bytes: 4, sha256: '092c79e8f80e559e404bcf660c48f3522b67aba9ff1484b0367e1a4ddef7431d',
+                conflict_policy: 'reject', name: 'diag', new_name: 'diag-renamed', target: path, new_target: path, expected_type: 'any',
+                grantee_aid: aid, perms: 'r', visibility: 'private', operation: 'read', share_id: 'diag-share',
+            });
+            if (method === 'storage.create_folder' || method === 'storage.fs.mkdir')
+                params.path = runId;
+        }
+        if (method.startsWith('collab.')) {
+            const root = aid + ':/' + runId;
+            Object.assign(params, {
+                collab_root: root, doc: 'echo.txt', source: 'ZWNobw==', onto: 1, rev: 1, src: root, dest: root + '-clone',
+                group_aid: aid, grantee_aid: aid, perms: 'w', version: '1.0.0', version_a: '1.0.0', version_b: '1.0.1', from: 1, to: 1,
+            });
+        }
+        return params;
+    }
+}
 const INDEXED_DOCUMENT_SETTING_KEY_NAME_RE = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 const INDEXED_DOCUMENT_SETTING_RESERVED_BASES = new Set([
     'join',
@@ -25,8 +336,8 @@ export function stripNil(params = {}, keepNull = false) {
     }
     return out;
 }
-function splitAidStore(params) {
-    const out = stripNil(params ?? {});
+function splitAidStore(params, keepNull = false) {
+    const out = stripNil(params ?? {}, keepNull);
     const aidStore = out.aidStore ?? out.aid_store;
     delete out.aidStore;
     delete out.aid_store;
@@ -81,6 +392,7 @@ export class MessageThoughtFacade extends RpcFacade {
     }
 }
 export class MessageFacade extends RpcFacade {
+    peers(params) { return this.call('message.peers', params); }
     _thought;
     get thought() {
         if (!this._thought)
@@ -684,12 +996,30 @@ export class GroupFacade extends RpcFacade {
     getOnlineMembers(params) { return this.call('group.get_online_members', params); }
 }
 export class CredentialFacade extends RpcFacade {
-    create(options, signer) { return createCredential(options, signer); }
+    async current(input) {
+        return this.client._credentialCurrent ? this.client._credentialCurrent(input) : this.client._currentCredential?.(input) ?? null;
+    }
+    create(options, signer) {
+        const credential = createCredential(options, signer);
+        this.client._rememberCredential?.(credential, { issued: true, long_term: !('exp' in options) }, signer.certPem);
+        return credential;
+    }
     verifySignature(credential, resolveCertificate, now, audience) {
         verifyCredentialSignature(credential, resolveCertificate, now, audience);
+        if (isJsonObject(credential))
+            this.client._rememberCredential?.(credential, {}, resolveCertificate(String(credential.signature.cert_fingerprint)) ?? undefined);
         return { signature_valid: true, status_checked: false };
     }
-    verify(credential, context) { return verifyCredential(credential, context); }
+    verify(credential, context) {
+        const ensureCurrent = isJsonObject(credential) ? this.client._assertCredentialNotRevoked?.(credential, context.proofChain) : undefined;
+        const result = verifyCredential(credential, context);
+        if (isJsonObject(credential))
+            this.client._assertCredentialNotRevoked?.(credential, context.proofChain);
+        if (isJsonObject(credential))
+            this.client._rememberCredential?.(credential, { membership_binding: context.membershipBinding }, context.resolveCertificate(String(credential.signature.cert_fingerprint)) ?? undefined);
+        ensureCurrent?.();
+        return result;
+    }
     verifyRegistrationReceipt(receipt, credential, request, resolveCertificate, expectedServiceAid, now) {
         verifyRegistrationReceipt(receipt, credential, request, resolveCertificate, expectedServiceAid, now ?? Math.trunc(Date.now() / 1000));
         return { signature_valid: true, request_bound: true };
@@ -702,7 +1032,7 @@ export class CredentialFacade extends RpcFacade {
 }
 export class OrgLifecycleFacade extends RpcFacade {
     create(params) {
-        const split = splitAidStore(params);
+        const split = splitAidStore(params, true);
         return split.aidStore && this.client.createOrg ? this.client.createOrg(split.params, { aidStore: split.aidStore }) : this.call('org.lifecycle.create', split.params);
     }
     get(params) { return this.call('org.lifecycle.get', params); }
@@ -711,12 +1041,12 @@ export class OrgLifecycleFacade extends RpcFacade {
     suspend(params) { return this.call('org.lifecycle.suspend', params); }
     resume(params) { return this.call('org.lifecycle.resume', params); }
     dissolve(params) {
-        const split = splitAidStore(params);
+        const split = splitAidStore(params, true);
         return split.aidStore && this.client.dissolveOrg ? this.client.dissolveOrg(split.params, { aidStore: split.aidStore }) : this.call('org.lifecycle.dissolve', split.params);
     }
     transfer(params) { return this.call('org.lifecycle.transfer', params); }
     transferAccept(params) {
-        const split = splitAidStore(params);
+        const split = splitAidStore(params, true);
         return split.aidStore && this.client.completeOrgTransfer ? this.client.completeOrgTransfer(split.params, { aidStore: split.aidStore }) : this.call('org.lifecycle.transferAccept', split.params);
     }
     signTransferAcceptance(proposal, signer) { return signTransferAcceptance(proposal, signer); }
@@ -724,10 +1054,19 @@ export class OrgLifecycleFacade extends RpcFacade {
 export class OrgMemberFacade extends RpcFacade {
     createBinding(options, memberSigner, orgSigner) { return createMembershipBinding(options, memberSigner, orgSigner); }
     signBinding(binding, signer, party) { return signMembershipBinding(binding, signer, party); }
-    createCredential(binding, signer, options) { return createMemberCredential(binding, signer, options); }
+    createCredential(binding, signer, options) {
+        const credential = createMemberCredential(binding, signer, options);
+        this.client._rememberCredential?.(credential, { issued: true, long_term: !('exp' in options), membership_binding: binding }, signer.certPem);
+        return credential;
+    }
     list(params) { return this.call('org.member.list', params); }
     get(params) { return this.call('org.member.get', params); }
-    join(params) { return this.call('org.member.join', params); }
+    async join(params) {
+        const application = params && isJsonObject(params.membership_binding) && isJsonObject(params.terms)
+            ? structuredClone({ terms: params.terms, membership_binding: params.membership_binding }) : undefined;
+        const result = await this.call('org.member.join', params);
+        return application && isJsonObject(result) ? { ...result, application } : result;
+    }
     approveJoin(params) { return this.call('org.member.approveJoin', params); }
     renewCredential(params) { return this.call('org.member.renewCredential', params); }
     rejectJoin(params) { return this.call('org.member.rejectJoin', params); }
@@ -767,7 +1106,24 @@ export class OrgFacade extends RpcFacade {
         this.audit = new OrgAuditFacade(client);
         this.authz = new OrgAuthzFacade(client);
     }
-    prepareRequest(method, params, target, signer, options = {}) { return prepareOrganizationRequest(method, params, target, signer, options); }
+    prepareRequest(method, params, target, signer, options = {}) {
+        if (!('request_binding' in params) && !('signature' in params) && !('client_signature' in params) && isJsonObject(params.credentials)) {
+            let credentials = params.credentials;
+            for (const key of ['member_credential', 'approval_credential']) {
+                const credential = credentials[key];
+                if (!isJsonObject(credential))
+                    continue;
+                const current = this.client._currentCredential?.(credential);
+                if (!current?.credential || current.credential.cid === credential.cid)
+                    continue;
+                if (Array.isArray(params.proof_chain) && Array.isArray(credential.proof_chain) && digest(params.proof_chain) === digest(credential.proof_chain))
+                    params = { ...params, proof_chain: current.credential.proof_chain };
+                credentials = { ...credentials, [key]: current.credential, ...(current.membership_binding ? { membership_binding: current.membership_binding } : {}) };
+                params = { ...params, credentials };
+            }
+        }
+        return prepareOrganizationRequest(method, params, target, signer, options);
+    }
     health(params) { return this.call('org.health', params); }
     status(params) { return this.call('org.status', params); }
 }