quorum-eliza-plugin 0.1.0

package/README.md

@@ -0,0 +1,113 @@
+# @quorum/eliza-plugin
+
+Multi-agent wallet coordination for [Eliza](https://github.com/ai16z/eliza) agents via [Quorum](https://quorumclaw.com).
+
+## Features
+
+- 🔐 **Create multi-agent wallets** - Set up m-of-n multisigs across agents
+- 🤝 **Join existing wallets** - Accept invites from other agents
+- ✍️ **Sign proposals** - Approve spending from shared treasuries
+- 📋 **Track proposals** - See pending transactions needing signatures
+- ⚡ **Auto-broadcast** - Transactions broadcast when threshold is met
+
+## Supported Chains
+
+- Bitcoin (Taproot multisig)
+- Ethereum (Safe)
+- Solana (Squads)
+- Base
+- Stacks
+
+## Installation
+
+```bash
+npm install @quorum/eliza-plugin
+```
+
+## Usage
+
+```typescript
+import { quorumPlugin } from '@quorum/eliza-plugin';
+
+export const agent = {
+  name: 'MyAgent',
+  plugins: [quorumPlugin],
+  settings: {
+    // Your agent's private key (Schnorr-compatible)
+    QUORUM_PRIVATE_KEY: process.env.AGENT_PRIVATE_KEY,
+  },
+};
+```
+
+## Actions
+
+### Create a multisig
+```
+"Create a 2-of-3 Bitcoin multisig called Team Treasury"
+```
+
+### Join a multisig
+```
+"Join multisig with code abc12345"
+```
+
+### List pending proposals
+```
+"Show pending proposals"
+```
+
+### Sign a proposal
+```
+"Sign proposal 7c34ae57-cb79-4195-a2a0-d225dd18e598"
+```
+
+### Create a spending proposal
+```
+"Send 5000 sats to bc1q... from our treasury"
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `QUORUM_PRIVATE_KEY` | Your agent's private key (hex, 32 bytes) |
+| `QUORUM_API_URL` | API endpoint (default: https://quorumclaw.com) |
+
+## How It Works
+
+1. **Registration**: On startup, the plugin registers your agent with Quorum using your public key
+2. **Coordination**: Agents create/join multisigs via invite codes
+3. **Proposals**: Any agent can propose spending from the shared wallet
+4. **Signing**: Each agent signs proposals independently (no MuSig2 rounds needed)
+5. **Broadcast**: When threshold is met, the transaction auto-broadcasts
+
+## Architecture
+
+```
+┌─────────────────┐     ┌─────────────────┐
+│  Eliza Agent A  │     │  Eliza Agent B  │
+│  (plugin-quorum)│     │  (plugin-quorum)│
+└────────┬────────┘     └────────┬────────┘
+         │                       │
+         └───────────┬───────────┘
+                     │
+              ┌──────▼──────┐
+              │   Quorum    │
+              │     API     │
+              └──────┬──────┘
+                     │
+              ┌──────▼──────┐
+              │  Blockchain │
+              │  (Bitcoin)  │
+              └─────────────┘
+```
+
+## Links
+
+- [Quorum API Docs](https://quorumclaw.com/docs)
+- [npm: quorum-sdk](https://www.npmjs.com/package/quorum-sdk)
+- [GitHub](https://github.com/aetos53t/agent-multisig-api)
+
+## License
+
+MIT

package/dist/actions/createMultisig.d.ts

@@ -0,0 +1,13 @@
+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>;
+};

package/dist/actions/createMultisig.js

@@ -0,0 +1,61 @@
+import { quorumService } from '../services/quorum.js';
+export const createMultisigAction = {
+    name: 'QUORUM_CREATE_MULTISIG',
+    description: 'Create a new multi-agent wallet via Quorum',
+    similes: [
+        'create multisig',
+        'create multi-agent wallet',
+        'setup shared wallet',
+        'create treasury',
+        'create quorum wallet',
+    ],
+    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.' } },
+        ],
+    ],
+    validate: async (runtime, message) => {
+        const text = message.content?.text?.toLowerCase() || '';
+        return text.includes('create') && (text.includes('multisig') || text.includes('wallet') || text.includes('treasury'));
+    },
+    handler: async (runtime, message, state, options, callback) => {
+        try {
+            const text = message.content?.text || '';
+            // Parse parameters from message
+            const thresholdMatch = text.match(/(\d+)[- ]of[- ](\d+)/i);
+            const threshold = thresholdMatch ? parseInt(thresholdMatch[1]) : 2;
+            const totalSigners = thresholdMatch ? parseInt(thresholdMatch[2]) : 3;
+            const nameMatch = text.match(/(?:called|named)\s+["']?([^"']+)["']?/i);
+            const name = nameMatch ? nameMatch[1].trim() : `Multisig ${Date.now()}`;
+            // Detect chain
+            let chainId = 'bitcoin-mainnet';
+            if (text.includes('ethereum') || text.includes('eth'))
+                chainId = 'ethereum';
+            if (text.includes('solana') || text.includes('sol'))
+                chainId = 'solana-mainnet';
+            if (text.includes('base'))
+                chainId = 'base';
+            if (text.includes('stacks') || text.includes('stx'))
+                chainId = 'stacks-mainnet';
+            const result = await quorumService.createMultisig({
+                name,
+                chainId,
+                threshold,
+                totalSigners,
+            });
+            const response = `✅ Created multisig "${name}" (${threshold}-of-${totalSigners} on ${chainId})
+
+**Invite Code:** \`${result.inviteCode}\`
+**Join Link:** https://quorumclaw.com/join/${result.inviteCode}
+
+Share this with other signers to join the wallet.`;
+            callback?.({ text: response });
+            return true;
+        }
+        catch (err) {
+            callback?.({ text: `❌ Failed to create multisig: ${err.message}` });
+            return false;
+        }
+    },
+};

package/dist/actions/createProposal.d.ts

@@ -0,0 +1,13 @@
+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>;
+};

package/dist/actions/createProposal.js

@@ -0,0 +1,79 @@
+import { quorumService } from '../services/quorum.js';
+export const createProposalAction = {
+    name: 'QUORUM_CREATE_PROPOSAL',
+    description: 'Create a new spending proposal in a multi-agent wallet',
+    similes: [
+        'send from multisig',
+        'create proposal',
+        'propose spend',
+        'propose transaction',
+        'send from treasury',
+    ],
+    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.' } },
+        ],
+    ],
+    validate: async (runtime, message) => {
+        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'));
+    },
+    handler: async (runtime, message, state, options, callback) => {
+        try {
+            const text = message.content?.text || '';
+            // 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..."' });
+                return false;
+            }
+            const amount = parseInt(amountMatch[1].replace(/,/g, ''));
+            // Parse recipient address
+            const addressMatch = text.match(/(bc1[a-z0-9]{39,87})/i) || // Bech32
+                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..."' });
+                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.' });
+                return false;
+            }
+            // Use first multisig or parse from message
+            // TODO: Allow specifying which multisig
+            const multisig = multisigs[0];
+            // Parse note
+            const noteMatch = text.match(/(?:note|memo|for|reason)[:\s]+["']?([^"']+)["']?/i);
+            const note = noteMatch ? noteMatch[1].trim() : undefined;
+            const proposal = await quorumService.createProposal({
+                multisigId: multisig.id,
+                recipient,
+                amount,
+                note,
+            });
+            callback?.({
+                text: `✅ **Proposal Created**
+
+**ID:** \`${proposal.id}\`
+**Amount:** ${amount.toLocaleString()} sats
+**To:** ${recipient}
+**From:** ${multisig.name}
+
+Proposal needs ${multisig.threshold} signatures. Share the proposal ID with other signers.
+
+https://quorumclaw.com/p/${proposal.id}`
+            });
+            return true;
+        }
+        catch (err) {
+            callback?.({ text: `❌ Failed to create proposal: ${err.message}` });
+            return false;
+        }
+    },
+};

package/dist/actions/joinMultisig.d.ts

@@ -0,0 +1,13 @@
+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>;
+};

package/dist/actions/joinMultisig.js

@@ -0,0 +1,49 @@
+import { quorumService } from '../services/quorum.js';
+export const joinMultisigAction = {
+    name: 'QUORUM_JOIN_MULTISIG',
+    description: 'Join an existing multi-agent wallet via invite code',
+    similes: [
+        'join multisig',
+        'join wallet',
+        'accept invite',
+        'join treasury',
+    ],
+    examples: [
+        [
+            { user: '{{user1}}', content: { text: 'Join multisig with code abc123' } },
+            { user: '{{agent}}', content: { text: 'Joined multisig "Team Treasury"! Address: bc1p...' } },
+        ],
+    ],
+    validate: async (runtime, message) => {
+        const text = message.content?.text?.toLowerCase() || '';
+        return text.includes('join') && (text.includes('multisig') || text.includes('wallet') || text.includes('code'));
+    },
+    handler: async (runtime, message, state, options, callback) => {
+        try {
+            const text = message.content?.text || '';
+            // Extract invite code
+            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"' });
+                return false;
+            }
+            const inviteCode = codeMatch[1];
+            const multisig = await quorumService.joinMultisig(inviteCode);
+            const response = `✅ Joined multisig "${multisig.name}"!
+
+**Address:** \`${multisig.address}\`
+**Threshold:** ${multisig.threshold}-of-${multisig.agents.length}
+**Chain:** ${multisig.chainId}
+**Signers:** ${multisig.agents.map(a => a.name).join(', ')}
+
+The wallet is ready to receive funds.`;
+            callback?.({ text: response });
+            return true;
+        }
+        catch (err) {
+            callback?.({ text: `❌ Failed to join multisig: ${err.message}` });
+            return false;
+        }
+    },
+};

package/dist/actions/listProposals.d.ts

@@ -0,0 +1,13 @@
+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>;
+};

package/dist/actions/listProposals.js

@@ -0,0 +1,47 @@
+import { quorumService } from '../services/quorum.js';
+export const listProposalsAction = {
+    name: 'QUORUM_LIST_PROPOSALS',
+    description: 'List pending proposals across all multi-agent wallets',
+    similes: [
+        'list proposals',
+        'show proposals',
+        'pending transactions',
+        'what needs signing',
+        'check proposals',
+    ],
+    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)' } },
+        ],
+    ],
+    validate: async (runtime, message) => {
+        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'));
+    },
+    handler: async (runtime, message, state, options, callback) => {
+        try {
+            const proposals = await quorumService.listPendingProposals();
+            if (proposals.length === 0) {
+                callback?.({ text: '✅ No pending proposals. All caught up!' });
+                return true;
+            }
+            const list = proposals.map(p => {
+                const amount = p.outputs.reduce((sum, o) => sum + parseInt(o.amount), 0);
+                const recipient = p.outputs[0]?.address || 'unknown';
+                const shortRecipient = `${recipient.slice(0, 8)}...${recipient.slice(-6)}`;
+                return `• **${amount.toLocaleString()} sats** → ${shortRecipient}
+  ID: \`${p.id.slice(0, 8)}...\` | Sigs: ${p.signatures.length}/? | ${p.note || 'No note'}`;
+            }).join('\n\n');
+            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}` });
+            return false;
+        }
+    },
+};

package/dist/actions/signProposal.d.ts

@@ -0,0 +1,13 @@
+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>;
+};

package/dist/actions/signProposal.js

@@ -0,0 +1,72 @@
+import { quorumService } from '../services/quorum.js';
+export const signProposalAction = {
+    name: 'QUORUM_SIGN_PROPOSAL',
+    description: 'Sign a pending proposal in a multi-agent wallet',
+    similes: [
+        'sign proposal',
+        'approve transaction',
+        'sign tx',
+        'approve proposal',
+        'co-sign',
+    ],
+    examples: [
+        [
+            { user: '{{user1}}', content: { text: 'Sign proposal abc123' } },
+            { user: '{{agent}}', content: { text: 'Signed! 2/3 signatures collected. Waiting for one more signer.' } },
+        ],
+    ],
+    validate: async (runtime, message) => {
+        const text = message.content?.text?.toLowerCase() || '';
+        return (text.includes('sign') || text.includes('approve')) &&
+            (text.includes('proposal') || text.includes('transaction') || text.includes('tx'));
+    },
+    handler: async (runtime, message, state, options, callback) => {
+        try {
+            const text = message.content?.text || '';
+            // Extract proposal ID (UUID format)
+            const idMatch = text.match(/([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i) ||
+                text.match(/proposal\s+([a-f0-9-]+)/i);
+            if (!idMatch) {
+                // 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.' });
+                    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}` });
+                    }
+                    else {
+                        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}` });
+                return false;
+            }
+            const proposalId = idMatch[1];
+            const result = await quorumService.signProposal(proposalId);
+            if (result.txid) {
+                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?.({
+                    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}` });
+            return false;
+        }
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Quorum Plugin for Eliza
+ *
+ * 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>;
+    }[];
+};
+export default quorumPlugin;
+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';

package/dist/index.js

@@ -0,0 +1,36 @@
+/**
+ * Quorum Plugin for Eliza
+ *
+ * Enables any Eliza agent to participate in multi-agent wallets via Quorum.
+ */
+import { quorumService } from './services/quorum.js';
+import { createMultisigAction } from './actions/createMultisig.js';
+import { joinMultisigAction } from './actions/joinMultisig.js';
+import { signProposalAction } from './actions/signProposal.js';
+import { listProposalsAction } from './actions/listProposals.js';
+import { createProposalAction } from './actions/createProposal.js';
+import { multisigProvider } from './providers/multisigInfo.js';
+export const quorumPlugin = {
+    name: 'quorum',
+    description: 'Multi-agent wallet coordination via Quorum',
+    // Initialize on plugin load
+    async init(runtime) {
+        await quorumService.initialize(runtime);
+    },
+    actions: [
+        createMultisigAction,
+        joinMultisigAction,
+        signProposalAction,
+        listProposalsAction,
+        createProposalAction,
+    ],
+    providers: [multisigProvider],
+};
+export default quorumPlugin;
+// Re-export for convenience
+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';

package/dist/providers/multisigInfo.d.ts

@@ -0,0 +1,5 @@
+export declare const multisigProvider: {
+    name: string;
+    description: string;
+    get: (runtime: any, message: any, state?: any) => Promise<any>;
+};

package/dist/providers/multisigInfo.js

@@ -0,0 +1,39 @@
+import { quorumService } from '../services/quorum.js';
+export const multisigProvider = {
+    name: 'QUORUM_MULTISIG_INFO',
+    description: 'Provides context about multi-agent wallets and pending proposals',
+    get: async (runtime, message, state) => {
+        try {
+            const agentId = quorumService.getAgentId();
+            if (!agentId) {
+                return ''; // Not initialized
+            }
+            const multisigs = await quorumService.listMultisigs();
+            const proposals = await quorumService.listPendingProposals();
+            if (multisigs.length === 0 && proposals.length === 0) {
+                return ''; // No relevant context
+            }
+            let context = '## Quorum Multi-Agent Wallets\n\n';
+            if (multisigs.length > 0) {
+                context += '### My Wallets\n';
+                for (const ms of multisigs) {
+                    context += `- **${ms.name}**: ${ms.address.slice(0, 12)}... (${ms.threshold}-of-${ms.agents.length} on ${ms.chainId})\n`;
+                }
+                context += '\n';
+            }
+            if (proposals.length > 0) {
+                context += '### ⚠️ Pending Proposals Requiring Signature\n';
+                for (const p of proposals) {
+                    const amount = p.outputs.reduce((sum, o) => sum + parseInt(o.amount), 0);
+                    context += `- **${amount} sats** to ${p.outputs[0]?.address.slice(0, 12)}... [${p.signatures.length} sigs] - ID: ${p.id.slice(0, 8)}...\n`;
+                }
+                context += '\nUse "sign proposal <id>" to approve these transactions.\n';
+            }
+            return context;
+        }
+        catch (err) {
+            console.error('[Quorum Provider] Error:', err);
+            return '';
+        }
+    },
+};