quorum-eliza-plugin 0.1.0

package/src/index.ts

@@ -0,0 +1,43 @@
+/**
+ * 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: any) {
+    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/src/providers/multisigInfo.ts

@@ -0,0 +1,46 @@
+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: any, message: any, state?: any): Promise<any> => {
+    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 '';
+    }
+  },
+};

package/src/services/quorum.ts

@@ -0,0 +1,246 @@
+/**
+ * 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';
+
+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;
+}
+
+class QuorumService {
+  private agentId: string | null = null;
+  private publicKey: string | null = null;
+  private privateKey: Uint8Array | null = null;
+  
+  get capabilityDescription(): string {
+    return 'Multi-agent wallet coordination via Quorum';
+  }
+  
+  async initialize(runtime: any): Promise<void> {
+    // 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: string): Promise<QuorumAgent> {
+    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: {
+    name: string;
+    chainId: string;
+    threshold: number;
+    totalSigners: number;
+  }): Promise<{ multisig: QuorumMultisig; inviteCode: string }> {
+    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: string): Promise<QuorumMultisig> {
+    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(): Promise<QuorumMultisig[]> {
+    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(): Promise<QuorumProposal[]> {
+    const multisigs = await this.listMultisigs();
+    const proposals: QuorumProposal[] = [];
+    
+    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: string): Promise<QuorumProposal> {
+    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: string): Promise<{ success: boolean; status: string; txid?: string }> {
+    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: {
+    multisigId: string;
+    recipient: string;
+    amount: number;
+    note?: string;
+  }): Promise<QuorumProposal> {
+    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(): string | null {
+    return this.agentId;
+  }
+  
+  getPublicKey(): string | null {
+    return this.publicKey;
+  }
+}
+
+export const quorumService = new QuorumService();
+export default quorumService;

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noImplicitAny": false
+  },
+  "include": ["src/**/*"]
+}