quorum-eliza-plugin 0.1.0

package/dist/services/quorum.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Quorum Service for Eliza
+ *
+ * Manages connection to Quorum API and handles signing operations.
+ */
+export interface QuorumAgent {
+    id: string;
+    name: string;
+    publicKey: string;
+}
+export interface QuorumMultisig {
+    id: string;
+    name: string;
+    address: string;
+    chainId: string;
+    threshold: number;
+    agents: QuorumAgent[];
+}
+export interface QuorumProposal {
+    id: string;
+    multisigId: string;
+    status: 'pending' | 'finalized' | 'expired';
+    outputs: Array<{
+        address: string;
+        amount: string;
+    }>;
+    signatures: Array<{
+        agentId: string;
+        signature: string;
+    }>;
+    sighashes: Array<{
+        inputIndex: number;
+        sighash: string;
+    }>;
+    note?: string;
+    createdAt: string;
+}
+declare class QuorumService {
+    private agentId;
+    private publicKey;
+    private privateKey;
+    get capabilityDescription(): string;
+    initialize(runtime: any): Promise<void>;
+    register(name: string): Promise<QuorumAgent>;
+    createMultisig(params: {
+        name: string;
+        chainId: string;
+        threshold: number;
+        totalSigners: number;
+    }): Promise<{
+        multisig: QuorumMultisig;
+        inviteCode: string;
+    }>;
+    joinMultisig(inviteCode: string): Promise<QuorumMultisig>;
+    listMultisigs(): Promise<QuorumMultisig[]>;
+    listPendingProposals(): Promise<QuorumProposal[]>;
+    getProposal(proposalId: string): Promise<QuorumProposal>;
+    signProposal(proposalId: string): Promise<{
+        success: boolean;
+        status: string;
+        txid?: string;
+    }>;
+    createProposal(params: {
+        multisigId: string;
+        recipient: string;
+        amount: number;
+        note?: string;
+    }): Promise<QuorumProposal>;
+    getAgentId(): string | null;
+    getPublicKey(): string | null;
+}
+export declare const quorumService: QuorumService;
+export default quorumService;

package/dist/services/quorum.js

@@ -0,0 +1,179 @@
+/**
+ * Quorum Service for Eliza
+ *
+ * Manages connection to Quorum API and handles signing operations.
+ */
+import { schnorr } from '@noble/curves/secp256k1';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
+const QUORUM_API = process.env.QUORUM_API_URL || 'https://quorumclaw.com';
+class QuorumService {
+    agentId = null;
+    publicKey = null;
+    privateKey = null;
+    get capabilityDescription() {
+        return 'Multi-agent wallet coordination via Quorum';
+    }
+    async initialize(runtime) {
+        // Try to get private key from runtime settings
+        const privateKeyHex = runtime.getSetting?.('QUORUM_PRIVATE_KEY') ||
+            runtime.getSetting?.('WALLET_PRIVATE_KEY') ||
+            process.env.QUORUM_PRIVATE_KEY;
+        if (!privateKeyHex) {
+            console.warn('[Quorum] No private key configured. Set QUORUM_PRIVATE_KEY or WALLET_PRIVATE_KEY.');
+            return;
+        }
+        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}`);
+        }
+        catch (err) {
+            console.error('[Quorum] Failed to initialize:', err);
+        }
+    }
+    async register(name) {
+        if (!this.publicKey)
+            throw new Error('No public key available');
+        const res = await fetch(`${QUORUM_API}/v1/agents`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name,
+                publicKey: this.publicKey,
+                provider: 'eliza',
+            }),
+        });
+        const json = await res.json();
+        if (!json.success)
+            throw new Error(json.error?.message || 'Registration failed');
+        this.agentId = json.data.id;
+        return json.data;
+    }
+    async createMultisig(params) {
+        if (!this.agentId)
+            throw new Error('Not registered with Quorum');
+        const res = await fetch(`${QUORUM_API}/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,
+            }),
+        });
+        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,
+        };
+    }
+    async joinMultisig(inviteCode) {
+        if (!this.agentId)
+            throw new Error('Not registered with Quorum');
+        const res = await fetch(`${QUORUM_API}/v1/invites/${inviteCode}/join`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ agentId: this.agentId }),
+        });
+        const json = await res.json();
+        if (!json.success)
+            throw new Error(json.error?.message || 'Join failed');
+        return json.data.multisig;
+    }
+    async listMultisigs() {
+        if (!this.agentId)
+            return [];
+        const res = await fetch(`${QUORUM_API}/v1/agents/${this.agentId}/multisigs`);
+        const json = await res.json();
+        return json.success ? json.data : [];
+    }
+    async listPendingProposals() {
+        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 json = await res.json();
+            if (json.success) {
+                proposals.push(...json.data);
+            }
+        }
+        return proposals;
+    }
+    async getProposal(proposalId) {
+        const res = await fetch(`${QUORUM_API}/v1/proposals/${proposalId}`);
+        const json = await res.json();
+        if (!json.success)
+            throw new Error(json.error?.message || 'Proposal not found');
+        return json.data;
+    }
+    async signProposal(proposalId) {
+        if (!this.agentId || !this.privateKey) {
+            throw new Error('Not initialized');
+        }
+        // Get proposal to get sighash
+        const proposal = await this.getProposal(proposalId);
+        if (proposal.status !== 'pending') {
+            throw new Error(`Proposal is ${proposal.status}, not pending`);
+        }
+        // Check if we already signed
+        if (proposal.signatures.some(s => s.agentId === this.agentId)) {
+            throw new Error('Already signed this proposal');
+        }
+        // Sign each input's sighash
+        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`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    agentId: this.agentId,
+                    signature: bytesToHex(signature),
+                    inputIndex: sh.inputIndex,
+                }),
+            });
+            const json = await res.json();
+            if (!json.success)
+                throw new Error(json.error?.message || 'Sign failed');
+            if (json.data.thresholdMet) {
+                return {
+                    success: true,
+                    status: 'finalized',
+                    txid: json.data.txid,
+                };
+            }
+        }
+        return { success: true, status: 'pending' };
+    }
+    async createProposal(params) {
+        const res = await fetch(`${QUORUM_API}/v1/proposals`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                multisigId: params.multisigId,
+                outputs: [{ address: params.recipient, amount: params.amount.toString() }],
+                note: params.note,
+                createdBy: this.agentId,
+            }),
+        });
+        const json = await res.json();
+        if (!json.success)
+            throw new Error(json.error?.message || 'Create proposal failed');
+        return json.data;
+    }
+    getAgentId() {
+        return this.agentId;
+    }
+    getPublicKey() {
+        return this.publicKey;
+    }
+}
+export const quorumService = new QuorumService();
+export default quorumService;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "quorum-eliza-plugin",
+  "version": "0.1.0",
+  "description": "Quorum multi-agent wallet plugin for Eliza",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "keywords": ["eliza", "quorum", "multisig", "ai-agents", "bitcoin", "wallet"],
+  "author": "The House of Set",
+  "license": "MIT",
+  "homepage": "https://quorumclaw.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aetos53t/agent-multisig-api"
+  },
+  "peerDependencies": {
+    "@elizaos/core": ">=1.0.0"
+  },
+  "dependencies": {
+    "quorum-sdk": "^0.1.0",
+    "@noble/curves": "^1.4.0",
+    "@noble/hashes": "^1.4.0"
+  },
+  "devDependencies": {
+    "@elizaos/core": "^1.0.0",
+    "typescript": "^5.3.3"
+  }
+}

package/src/actions/createMultisig.ts

@@ -0,0 +1,74 @@
+
+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: any, message: any): Promise<any> => {
+    const text = message.content?.text?.toLowerCase() || '';
+    return text.includes('create') && (text.includes('multisig') || text.includes('wallet') || text.includes('treasury'));
+  },
+  
+  handler: async (
+    runtime: any,
+    message: any,
+    state: any,
+    options: Record<string, unknown>,
+    callback?: any
+  ): Promise<any> => {
+    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: any) {
+      callback?.({ text: `❌ Failed to create multisig: ${err.message}` });
+      return false;
+    }
+  },
+};

package/src/actions/createProposal.ts

@@ -0,0 +1,99 @@
+
+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: any, message: any): Promise<any> => {
+    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: any,
+    message: any,
+    state: any,
+    options: Record<string, unknown>,
+    callback?: any
+  ): Promise<any> => {
+    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: any) {
+      callback?.({ text: `❌ Failed to create proposal: ${err.message}` });
+      return false;
+    }
+  },
+};

package/src/actions/joinMultisig.ts

@@ -0,0 +1,65 @@
+
+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: any, message: any): Promise<any> => {
+    const text = message.content?.text?.toLowerCase() || '';
+    return text.includes('join') && (text.includes('multisig') || text.includes('wallet') || text.includes('code'));
+  },
+  
+  handler: async (
+    runtime: any,
+    message: any,
+    state: any,
+    options: Record<string, unknown>,
+    callback?: any
+  ): Promise<any> => {
+    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: any) {
+      callback?.({ text: `❌ Failed to join multisig: ${err.message}` });
+      return false;
+    }
+  },
+};

package/src/actions/listProposals.ts

@@ -0,0 +1,62 @@
+
+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: any, message: any): Promise<any> => {
+    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: any,
+    message: any,
+    state: any,
+    options: Record<string, unknown>,
+    callback?: any
+  ): Promise<any> => {
+    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: any) {
+      callback?.({ text: `❌ Failed to list proposals: ${err.message}` });
+      return false;
+    }
+  },
+};

package/src/actions/signProposal.ts

@@ -0,0 +1,92 @@
+
+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: any, message: any): Promise<any> => {
+    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: any,
+    message: any,
+    state: any,
+    options: Record<string, unknown>,
+    callback?: any
+  ): Promise<any> => {
+    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: any) {
+      callback?.({ text: `❌ Failed to sign: ${err.message}` });
+      return false;
+    }
+  },
+};