quorum-eliza-plugin 0.2.0 → 0.3.0

package/dist/actions/createMultisig.d.ts

@@ -1,13 +1,2 @@
-export declare const createMultisigAction: {
-    name: string;
-    description: string;
-    similes: string[];
-    examples: {
-        user: string;
-        content: {
-            text: string;
-        };
-    }[][];
-    validate: (runtime: any, message: any) => Promise<any>;
-    handler: (runtime: any, message: any, state: any, options: Record<string, unknown>, callback?: any) => Promise<any>;
-};
+import type { Action } from '../types.js';
+export declare const createMultisigAction: Action;

package/dist/actions/createMultisig.js

@@ -11,11 +11,11 @@ export const createMultisigAction = {
     ],
     examples: [
         [
-            { user: '{{user1}}', content: { text: 'Create a 2-of-3 Bitcoin multisig called "Team Treasury"' } },
-            { user: '{{agent}}', content: { text: 'Created multisig "Team Treasury" (2-of-3). Invite code: abc123. Share this with other signers to join.' } },
+            { name: '{{user1}}', content: { text: 'Create a 2-of-3 Bitcoin multisig called "Team Treasury"' } },
+            { name: '{{agent}}', content: { text: 'Created multisig "Team Treasury" (2-of-3). Invite code: abc123. Share this with other signers to join.' } },
         ],
     ],
-    validate: async (runtime, message) => {
+    validate: async (runtime, message, state) => {
         const text = message.content?.text?.toLowerCase() || '';
         return text.includes('create') && (text.includes('multisig') || text.includes('wallet') || text.includes('treasury'));
     },
@@ -50,11 +50,11 @@ export const createMultisigAction = {
 **Join Link:** https://quorumclaw.com/join/${result.inviteCode}
 
 Share this with other signers to join the wallet.`;
-            callback?.({ text: response });
+            await callback?.({ text: response });
             return true;
         }
         catch (err) {
-            callback?.({ text: `❌ Failed to create multisig: ${err.message}` });
+            await callback?.({ text: `❌ Failed to create multisig: ${err.message}` });
             return false;
         }
     },

package/dist/actions/createProposal.d.ts

@@ -1,13 +1,2 @@
-export declare const createProposalAction: {
-    name: string;
-    description: string;
-    similes: string[];
-    examples: {
-        user: string;
-        content: {
-            text: string;
-        };
-    }[][];
-    validate: (runtime: any, message: any) => Promise<any>;
-    handler: (runtime: any, message: any, state: any, options: Record<string, unknown>, callback?: any) => Promise<any>;
-};
+import type { Action } from '../types.js';
+export declare const createProposalAction: Action;

package/dist/actions/createProposal.js

@@ -11,11 +11,11 @@ export const createProposalAction = {
     ],
     examples: [
         [
-            { user: '{{user1}}', content: { text: 'Send 5000 sats to bc1q... from our treasury' } },
-            { user: '{{agent}}', content: { text: 'Created proposal! ID: abc123. Waiting for 2 more signatures.' } },
+            { name: '{{user1}}', content: { text: 'Send 5000 sats to bc1q... from our treasury' } },
+            { name: '{{agent}}', content: { text: 'Created proposal! ID: abc123. Waiting for 2 more signatures.' } },
         ],
     ],
-    validate: async (runtime, message) => {
+    validate: async (runtime, message, state) => {
         const text = message.content?.text?.toLowerCase() || '';
         return (text.includes('send') || text.includes('propose') || text.includes('transfer')) &&
             (text.includes('multisig') || text.includes('treasury') || text.includes('proposal') || text.includes('sats'));
@@ -26,7 +26,7 @@ export const createProposalAction = {
             // Parse amount
             const amountMatch = text.match(/(\d+(?:,\d+)?)\s*(?:sats?|satoshis?)/i);
             if (!amountMatch) {
-                callback?.({ text: '❌ Please specify an amount in sats. Example: "Send 5000 sats to bc1q..."' });
+                await callback?.({ text: '❌ Please specify an amount in sats. Example: "Send 5000 sats to bc1q..."' });
                 return false;
             }
             const amount = parseInt(amountMatch[1].replace(/,/g, ''));
@@ -35,14 +35,14 @@ export const createProposalAction = {
                 text.match(/(tb1[a-z0-9]{39,87})/i) || // Testnet
                 text.match(/(0x[a-fA-F0-9]{40})/i); // EVM
             if (!addressMatch) {
-                callback?.({ text: '❌ Please provide a recipient address. Example: "Send 5000 sats to bc1q..."' });
+                await callback?.({ text: '❌ Please provide a recipient address. Example: "Send 5000 sats to bc1q..."' });
                 return false;
             }
             const recipient = addressMatch[1];
             // Get multisigs
             const multisigs = await quorumService.listMultisigs();
             if (multisigs.length === 0) {
-                callback?.({ text: '❌ You are not part of any multisigs. Create or join one first.' });
+                await callback?.({ text: '❌ You are not part of any multisigs. Create or join one first.' });
                 return false;
             }
             // Use first multisig or parse from message
@@ -57,7 +57,7 @@ export const createProposalAction = {
                 amount,
                 note,
             });
-            callback?.({
+            await callback?.({
                 text: `✅ **Proposal Created**
 
 **ID:** \`${proposal.id}\`
@@ -72,7 +72,7 @@ https://quorumclaw.com/p/${proposal.id}`
             return true;
         }
         catch (err) {
-            callback?.({ text: `❌ Failed to create proposal: ${err.message}` });
+            await callback?.({ text: `❌ Failed to create proposal: ${err.message}` });
             return false;
         }
     },

package/dist/actions/joinMultisig.d.ts

@@ -1,13 +1,2 @@
-export declare const joinMultisigAction: {
-    name: string;
-    description: string;
-    similes: string[];
-    examples: {
-        user: string;
-        content: {
-            text: string;
-        };
-    }[][];
-    validate: (runtime: any, message: any) => Promise<any>;
-    handler: (runtime: any, message: any, state: any, options: Record<string, unknown>, callback?: any) => Promise<any>;
-};
+import type { Action } from '../types.js';
+export declare const joinMultisigAction: Action;

package/dist/actions/joinMultisig.js

@@ -10,11 +10,11 @@ export const joinMultisigAction = {
     ],
     examples: [
         [
-            { user: '{{user1}}', content: { text: 'Join multisig with code abc123' } },
-            { user: '{{agent}}', content: { text: 'Joined multisig "Team Treasury"! Address: bc1p...' } },
+            { name: '{{user1}}', content: { text: 'Join multisig with code abc123' } },
+            { name: '{{agent}}', content: { text: 'Joined multisig "Team Treasury"! Address: bc1p...' } },
         ],
     ],
-    validate: async (runtime, message) => {
+    validate: async (runtime, message, state) => {
         const text = message.content?.text?.toLowerCase() || '';
         return text.includes('join') && (text.includes('multisig') || text.includes('wallet') || text.includes('code'));
     },
@@ -25,7 +25,7 @@ export const joinMultisigAction = {
             const codeMatch = text.match(/(?:code|invite)?\s*([a-f0-9]{8})/i) ||
                 text.match(/join\/([a-f0-9]{8})/i);
             if (!codeMatch) {
-                callback?.({ text: '❌ Please provide an invite code. Example: "Join multisig with code abc12345"' });
+                await callback?.({ text: '❌ Please provide an invite code. Example: "Join multisig with code abc12345"' });
                 return false;
             }
             const inviteCode = codeMatch[1];
@@ -38,11 +38,11 @@ export const joinMultisigAction = {
 **Signers:** ${multisig.agents.map(a => a.name).join(', ')}
 
 The wallet is ready to receive funds.`;
-            callback?.({ text: response });
+            await callback?.({ text: response });
             return true;
         }
         catch (err) {
-            callback?.({ text: `❌ Failed to join multisig: ${err.message}` });
+            await callback?.({ text: `❌ Failed to join multisig: ${err.message}` });
             return false;
         }
     },

package/dist/actions/listProposals.d.ts

@@ -1,13 +1,2 @@
-export declare const listProposalsAction: {
-    name: string;
-    description: string;
-    similes: string[];
-    examples: {
-        user: string;
-        content: {
-            text: string;
-        };
-    }[][];
-    validate: (runtime: any, message: any) => Promise<any>;
-    handler: (runtime: any, message: any, state: any, options: Record<string, unknown>, callback?: any) => Promise<any>;
-};
+import type { Action } from '../types.js';
+export declare const listProposalsAction: Action;

package/dist/actions/listProposals.js

@@ -11,11 +11,11 @@ export const listProposalsAction = {
     ],
     examples: [
         [
-            { user: '{{user1}}', content: { text: 'Show pending proposals' } },
-            { user: '{{agent}}', content: { text: 'You have 2 pending proposals:\n- 5000 sats to bc1q... (1/2 sigs)\n- 10000 sats to bc1p... (0/3 sigs)' } },
+            { name: '{{user1}}', content: { text: 'Show pending proposals' } },
+            { name: '{{agent}}', content: { text: 'You have 2 pending proposals:\n- 5000 sats to bc1q... (1/2 sigs)\n- 10000 sats to bc1p... (0/3 sigs)' } },
         ],
     ],
-    validate: async (runtime, message) => {
+    validate: async (runtime, message, state) => {
         const text = message.content?.text?.toLowerCase() || '';
         return (text.includes('list') || text.includes('show') || text.includes('pending') || text.includes('check')) &&
             (text.includes('proposal') || text.includes('transaction') || text.includes('signing'));
@@ -24,7 +24,7 @@ export const listProposalsAction = {
         try {
             const proposals = await quorumService.listPendingProposals();
             if (proposals.length === 0) {
-                callback?.({ text: '✅ No pending proposals. All caught up!' });
+                await callback?.({ text: '✅ No pending proposals. All caught up!' });
                 return true;
             }
             const list = proposals.map(p => {
@@ -34,13 +34,13 @@ export const listProposalsAction = {
                 return `• **${amount.toLocaleString()} sats** → ${shortRecipient}
   ID: \`${p.id.slice(0, 8)}...\` | Sigs: ${p.signatures.length}/? | ${p.note || 'No note'}`;
             }).join('\n\n');
-            callback?.({
+            await callback?.({
                 text: `📋 **Pending Proposals (${proposals.length})**\n\n${list}\n\nSay "sign proposal <id>" to approve.`
             });
             return true;
         }
         catch (err) {
-            callback?.({ text: `❌ Failed to list proposals: ${err.message}` });
+            await callback?.({ text: `❌ Failed to list proposals: ${err.message}` });
             return false;
         }
     },

package/dist/actions/signProposal.d.ts

@@ -1,13 +1,2 @@
-export declare const signProposalAction: {
-    name: string;
-    description: string;
-    similes: string[];
-    examples: {
-        user: string;
-        content: {
-            text: string;
-        };
-    }[][];
-    validate: (runtime: any, message: any) => Promise<any>;
-    handler: (runtime: any, message: any, state: any, options: Record<string, unknown>, callback?: any) => Promise<any>;
-};
+import type { Action } from '../types.js';
+export declare const signProposalAction: Action;

package/dist/actions/signProposal.js

@@ -11,11 +11,11 @@ export const signProposalAction = {
     ],
     examples: [
         [
-            { user: '{{user1}}', content: { text: 'Sign proposal abc123' } },
-            { user: '{{agent}}', content: { text: 'Signed! 2/3 signatures collected. Waiting for one more signer.' } },
+            { name: '{{user1}}', content: { text: 'Sign proposal abc123' } },
+            { name: '{{agent}}', content: { text: 'Signed! 2/3 signatures collected. Waiting for one more signer.' } },
         ],
     ],
-    validate: async (runtime, message) => {
+    validate: async (runtime, message, state) => {
         const text = message.content?.text?.toLowerCase() || '';
         return (text.includes('sign') || text.includes('approve')) &&
             (text.includes('proposal') || text.includes('transaction') || text.includes('tx'));
@@ -30,42 +30,42 @@ export const signProposalAction = {
                 // Try to find pending proposals
                 const pending = await quorumService.listPendingProposals();
                 if (pending.length === 0) {
-                    callback?.({ text: '❌ No pending proposals found. Provide a proposal ID or create a new proposal.' });
+                    await callback?.({ text: '❌ No pending proposals found. Provide a proposal ID or create a new proposal.' });
                     return false;
                 }
                 if (pending.length === 1) {
                     // Auto-sign the only pending proposal
                     const result = await quorumService.signProposal(pending[0].id);
                     if (result.txid) {
-                        callback?.({ text: `✅ Signed and broadcast! txid: ${result.txid}\n\nhttps://mempool.space/tx/${result.txid}` });
+                        await callback?.({ text: `✅ Signed and broadcast! txid: ${result.txid}\n\nhttps://mempool.space/tx/${result.txid}` });
                     }
                     else {
-                        callback?.({ text: `✅ Signed! Proposal status: ${result.status}. Waiting for more signatures.` });
+                        await callback?.({ text: `✅ Signed! Proposal status: ${result.status}. Waiting for more signatures.` });
                     }
                     return true;
                 }
                 // List pending proposals
                 const list = pending.map(p => `- \`${p.id.slice(0, 8)}...\`: ${p.outputs.map(o => `${o.amount} sats`).join(', ')} (${p.signatures.length} sigs)`).join('\n');
-                callback?.({ text: `Multiple pending proposals. Please specify which one:\n\n${list}` });
+                await callback?.({ text: `Multiple pending proposals. Please specify which one:\n\n${list}` });
                 return false;
             }
             const proposalId = idMatch[1];
             const result = await quorumService.signProposal(proposalId);
             if (result.txid) {
-                callback?.({
+                await callback?.({
                     text: `✅ **Threshold met! Transaction broadcast.**\n\n**txid:** \`${result.txid}\`\n\nhttps://mempool.space/tx/${result.txid}`
                 });
             }
             else {
                 const proposal = await quorumService.getProposal(proposalId);
-                callback?.({
+                await callback?.({
                     text: `✅ Signed! ${proposal.signatures.length}/${proposal.sighashes.length + 1} signatures collected. Waiting for more signers.`
                 });
             }
             return true;
         }
         catch (err) {
-            callback?.({ text: `❌ Failed to sign: ${err.message}` });
+            await callback?.({ text: `❌ Failed to sign: ${err.message}` });
             return false;
         }
     },

package/dist/index.d.ts

@@ -3,33 +3,15 @@
  *
  * Enables any Eliza agent to participate in multi-agent wallets via Quorum.
  */
-export declare const quorumPlugin: {
-    name: string;
-    description: string;
-    init(runtime: any): Promise<void>;
-    actions: {
-        name: string;
-        description: string;
-        similes: string[];
-        examples: {
-            user: string;
-            content: {
-                text: string;
-            };
-        }[][];
-        validate: (runtime: any, message: any) => Promise<any>;
-        handler: (runtime: any, message: any, state: any, options: Record<string, unknown>, callback?: any) => Promise<any>;
-    }[];
-    providers: {
-        name: string;
-        description: string;
-        get: (runtime: any, message: any, state?: any) => Promise<any>;
-    }[];
-};
+import type { Plugin } from './types.js';
+export declare const quorumPlugin: Plugin;
 export default quorumPlugin;
+export type { IAgentRuntime, Plugin, Action, Provider, Memory, State, Content, Handler, Validator, HandlerCallback, } from './types.js';
 export { quorumService } from './services/quorum.js';
-export * from './actions/createMultisig.js';
-export * from './actions/joinMultisig.js';
-export * from './actions/signProposal.js';
-export * from './actions/listProposals.js';
-export * from './actions/createProposal.js';
+export type { QuorumAgent, QuorumMultisig, QuorumProposal, QuorumConfig } from './services/quorum.js';
+export { createMultisigAction } from './actions/createMultisig.js';
+export { joinMultisigAction } from './actions/joinMultisig.js';
+export { signProposalAction } from './actions/signProposal.js';
+export { listProposalsAction } from './actions/listProposals.js';
+export { createProposalAction } from './actions/createProposal.js';
+export { multisigProvider } from './providers/multisigInfo.js';

package/dist/index.js

@@ -27,10 +27,11 @@ export const quorumPlugin = {
     providers: [multisigProvider],
 };
 export default quorumPlugin;
-// Re-export for convenience
+// Re-export service and actions
 export { quorumService } from './services/quorum.js';
-export * from './actions/createMultisig.js';
-export * from './actions/joinMultisig.js';
-export * from './actions/signProposal.js';
-export * from './actions/listProposals.js';
-export * from './actions/createProposal.js';
+export { createMultisigAction } from './actions/createMultisig.js';
+export { joinMultisigAction } from './actions/joinMultisig.js';
+export { signProposalAction } from './actions/signProposal.js';
+export { listProposalsAction } from './actions/listProposals.js';
+export { createProposalAction } from './actions/createProposal.js';
+export { multisigProvider } from './providers/multisigInfo.js';

package/dist/providers/multisigInfo.d.ts

@@ -1,5 +1,2 @@
-export declare const multisigProvider: {
-    name: string;
-    description: string;
-    get: (runtime: any, message: any, state?: any) => Promise<any>;
-};
+import type { Provider } from '../types.js';
+export declare const multisigProvider: Provider;

package/dist/services/quorum.d.ts

@@ -3,6 +3,7 @@
  *
  * Manages connection to Quorum API and handles signing operations.
  */
+import type { IAgentRuntime } from '../types.js';
 export interface QuorumAgent {
     id: string;
     name: string;
@@ -35,12 +36,25 @@ export interface QuorumProposal {
     note?: string;
     createdAt: string;
 }
+export interface QuorumConfig {
+    privateKey?: string;
+    apiUrl?: string;
+    agentName?: string;
+}
 declare class QuorumService {
     private agentId;
+    private agentName;
     private publicKey;
     private privateKey;
+    private apiUrl;
+    private initialized;
     get capabilityDescription(): string;
-    initialize(runtime: any): Promise<void>;
+    isInitialized(): boolean;
+    initialize(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Initialize with explicit config (useful for testing)
+     */
+    initializeWithConfig(config: QuorumConfig): Promise<void>;
     register(name: string): Promise<QuorumAgent>;
     createMultisig(params: {
         name: string;
@@ -51,7 +65,7 @@ declare class QuorumService {
         multisig: QuorumMultisig;
         inviteCode: string;
     }>;
-    joinMultisig(inviteCode: string): Promise<QuorumMultisig>;
+    joinMultisig(inviteCode: string, agentName?: string): Promise<QuorumMultisig>;
     listMultisigs(): Promise<QuorumMultisig[]>;
     listPendingProposals(): Promise<QuorumProposal[]>;
     getProposal(proposalId: string): Promise<QuorumProposal>;
@@ -68,6 +82,11 @@ declare class QuorumService {
     }): Promise<QuorumProposal>;
     getAgentId(): string | null;
     getPublicKey(): string | null;
+    getApiUrl(): string;
+    /**
+     * Reset service state (useful for testing)
+     */
+    reset(): void;
 }
 export declare const quorumService: QuorumService;
 export default quorumService;

package/dist/services/quorum.js

@@ -8,11 +8,17 @@ import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
 const QUORUM_API = process.env.QUORUM_API_URL || 'https://quorumclaw.com';
 class QuorumService {
     agentId = null;
+    agentName = null;
     publicKey = null;
     privateKey = null;
+    apiUrl = QUORUM_API;
+    initialized = false;
     get capabilityDescription() {
         return 'Multi-agent wallet coordination via Quorum';
     }
+    isInitialized() {
+        return this.initialized && this.agentId !== null;
+    }
     async initialize(runtime) {
         // Try to get private key from runtime settings
         const privateKeyHex = runtime.getSetting?.('QUORUM_PRIVATE_KEY') ||
@@ -22,75 +28,116 @@ class QuorumService {
             console.warn('[Quorum] No private key configured. Set QUORUM_PRIVATE_KEY or WALLET_PRIVATE_KEY.');
             return;
         }
+        // Get API URL override if set
+        const apiUrlOverride = runtime.getSetting?.('QUORUM_API_URL') || process.env.QUORUM_API_URL;
+        if (apiUrlOverride) {
+            this.apiUrl = apiUrlOverride;
+        }
         try {
             const keyHex = String(privateKeyHex).replace('0x', '');
             this.privateKey = hexToBytes(keyHex);
             this.publicKey = bytesToHex(schnorr.getPublicKey(this.privateKey));
             // Register with Quorum
-            await this.register(runtime.character?.name || 'Eliza Agent');
-            console.log(`[Quorum] Initialized. Agent ID: ${this.agentId}`);
+            const agentName = runtime.character?.name || 'Eliza Agent';
+            await this.register(agentName);
+            this.initialized = true;
+            console.log(`[Quorum] Initialized. Agent ID: ${this.agentId}, Public Key: ${this.publicKey?.slice(0, 16)}...`);
         }
         catch (err) {
             console.error('[Quorum] Failed to initialize:', err);
+            throw err;
+        }
+    }
+    /**
+     * Initialize with explicit config (useful for testing)
+     */
+    async initializeWithConfig(config) {
+        if (!config.privateKey) {
+            throw new Error('Private key is required');
         }
+        if (config.apiUrl) {
+            this.apiUrl = config.apiUrl;
+        }
+        const keyHex = config.privateKey.replace('0x', '');
+        this.privateKey = hexToBytes(keyHex);
+        this.publicKey = bytesToHex(schnorr.getPublicKey(this.privateKey));
+        await this.register(config.agentName || 'Test Agent');
+        this.initialized = true;
     }
     async register(name) {
         if (!this.publicKey)
             throw new Error('No public key available');
-        const res = await fetch(`${QUORUM_API}/v1/agents`, {
+        const res = await fetch(`${this.apiUrl}/v1/agents`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 name,
                 publicKey: this.publicKey,
-                provider: 'eliza',
+                provider: 'custom', // 'eliza' not in allowed enum, use 'custom'
+                metadata: { framework: 'eliza' }, // Store framework info in metadata
             }),
         });
         const json = await res.json();
         if (!json.success)
             throw new Error(json.error?.message || 'Registration failed');
         this.agentId = json.data.id;
+        this.agentName = name;
         return json.data;
     }
     async createMultisig(params) {
         if (!this.agentId)
             throw new Error('Not registered with Quorum');
-        const res = await fetch(`${QUORUM_API}/v1/invites`, {
+        const res = await fetch(`${this.apiUrl}/v1/invites`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 name: params.name,
                 chainId: params.chainId,
                 threshold: params.threshold,
-                slots: params.totalSigners,
-                creatorAgentId: this.agentId,
+                totalSigners: params.totalSigners,
             }),
         });
         const json = await res.json();
         if (!json.success)
             throw new Error(json.error?.message || 'Create failed');
         return {
-            multisig: json.data.multisig,
-            inviteCode: json.data.code,
+            multisig: json.data, // Invite data until multisig is finalized
+            inviteCode: json.data.inviteId || json.data.id,
         };
     }
-    async joinMultisig(inviteCode) {
-        if (!this.agentId)
-            throw new Error('Not registered with Quorum');
-        const res = await fetch(`${QUORUM_API}/v1/invites/${inviteCode}/join`, {
+    async joinMultisig(inviteCode, agentName) {
+        if (!this.publicKey)
+            throw new Error('Not initialized');
+        const res = await fetch(`${this.apiUrl}/v1/invites/${inviteCode}/join`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ agentId: this.agentId }),
+            body: JSON.stringify({
+                name: agentName || this.agentName || 'Agent',
+                publicKey: this.publicKey,
+            }),
         });
         const json = await res.json();
         if (!json.success)
             throw new Error(json.error?.message || 'Join failed');
-        return json.data.multisig;
+        // API returns invite data directly; convert to multisig format
+        const data = json.data;
+        return {
+            id: data.multisigId || data.id,
+            name: data.name,
+            address: data.address || 'pending',
+            chainId: data.chainId,
+            threshold: data.threshold,
+            agents: data.slots.filter((s) => s.publicKey).map((s) => ({
+                id: s.sessionId,
+                name: s.name,
+                publicKey: s.publicKey,
+            })),
+        };
     }
     async listMultisigs() {
         if (!this.agentId)
             return [];
-        const res = await fetch(`${QUORUM_API}/v1/agents/${this.agentId}/multisigs`);
+        const res = await fetch(`${this.apiUrl}/v1/agents/${this.agentId}/multisigs`);
         const json = await res.json();
         return json.success ? json.data : [];
     }
@@ -98,7 +145,7 @@ class QuorumService {
         const multisigs = await this.listMultisigs();
         const proposals = [];
         for (const ms of multisigs) {
-            const res = await fetch(`${QUORUM_API}/v1/proposals?multisigId=${ms.id}&status=pending`);
+            const res = await fetch(`${this.apiUrl}/v1/proposals?multisigId=${ms.id}&status=pending`);
             const json = await res.json();
             if (json.success) {
                 proposals.push(...json.data);
@@ -107,7 +154,7 @@ class QuorumService {
         return proposals;
     }
     async getProposal(proposalId) {
-        const res = await fetch(`${QUORUM_API}/v1/proposals/${proposalId}`);
+        const res = await fetch(`${this.apiUrl}/v1/proposals/${proposalId}`);
         const json = await res.json();
         if (!json.success)
             throw new Error(json.error?.message || 'Proposal not found');
@@ -130,7 +177,7 @@ class QuorumService {
         for (const sh of proposal.sighashes) {
             const sighashBytes = hexToBytes(sh.sighash);
             const signature = schnorr.sign(sighashBytes, this.privateKey);
-            const res = await fetch(`${QUORUM_API}/v1/proposals/${proposalId}/sign`, {
+            const res = await fetch(`${this.apiUrl}/v1/proposals/${proposalId}/sign`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({
@@ -153,7 +200,7 @@ class QuorumService {
         return { success: true, status: 'pending' };
     }
     async createProposal(params) {
-        const res = await fetch(`${QUORUM_API}/v1/proposals`, {
+        const res = await fetch(`${this.apiUrl}/v1/proposals`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
@@ -174,6 +221,20 @@ class QuorumService {
     getPublicKey() {
         return this.publicKey;
     }
+    getApiUrl() {
+        return this.apiUrl;
+    }
+    /**
+     * Reset service state (useful for testing)
+     */
+    reset() {
+        this.agentId = null;
+        this.agentName = null;
+        this.publicKey = null;
+        this.privateKey = null;
+        this.initialized = false;
+        this.apiUrl = QUORUM_API;
+    }
 }
 export const quorumService = new QuorumService();
 export default quorumService;