Floppy Keystore

Quick Start

1. Mount the Floppy Disk

node .claude/skills/floppy-keystore/scripts/cli.js mount

2. Create an Encrypted Keystore

node .claude/skills/floppy-keystore/scripts/cli.js create
# Enter your BIP-39 mnemonic (12 or 24 words)
# Set encryption password

3. Derive Keys for Any Chain

# Ethereum keys
node cli.js derive ethereum --count=5

# Bitcoin Native SegWit addresses
node cli.js derive bitcoin --type=nativeSegwit --count=3

# Solana keys
node cli.js derive solana --count=2

# Show addresses only (no private keys)
node cli.js address monero --count=10

CLI Commands

Derive Options

--count=N     # Number of accounts to derive (default: 1)
--start=N     # Starting index (default: 0)
--type=TYPE   # Address type (Bitcoin: legacy, segwit, nativeSegwit, taproot)

Programmatic Usage

Basic Ethereum (Hardhat Compatible)

const { loadFloppyKeysSync } = require('./.claude/skills/floppy-keystore/scripts/loader');

module.exports = {
  networks: {
    mainnet: {
      url: "https://eth.llamarpc.com",
      accounts: loadFloppyKeysSync()
    }
  }
};

Multi-Chain Key Derivation

const { deriveChainKeys, getChainAddresses } = require('./loader');

// Derive Ethereum keys
const ethKeys = await deriveChainKeys('ethereum', { count: 5 });

// Derive Bitcoin keys (Native SegWit)
const btcKeys = await deriveChainKeys('bitcoin', {
  count: 3,
  addressType: 'nativeSegwit'
});

// Derive Solana keys
const solKeys = await deriveChainKeys('solana', { count: 2 });

// Get just addresses
const xmrAddresses = await getChainAddresses('monero', { count: 10 });

Key Object Structure

// Ethereum/Bitcoin/Zcash (secp256k1)
{
  chain: 'ETH',
  index: 0,
  path: "m/44'/60'/0'/0/0",
  privateKey: '0x...',
  publicKey: '0x...',
  address: '0x...'
}

// Monero (ed25519 - dual key)
{
  chain: 'XMR',
  index: 0,
  path: 'derived/0',
  privateSpendKey: '...',
  privateViewKey: '...',
  address: '4...'
}

// Solana (ed25519)
{
  chain: 'SOL',
  index: 0,
  path: "m/44'/501'/0'/0'",
  privateKey: '...',
  publicKey: '...',  // Base58
  address: '...'     // Same as publicKey
}

Bitcoin Address Types

Bitcoin supports multiple address formats:

# Derive Bitcoin Taproot addresses
node cli.js derive bitcoin --type=taproot --count=5

Derivation Paths

Standard BIP-44 paths used for each chain:

Security Model

Encryption

• KDF: scrypt (N=262144, r=8, p=1) - ~512MB memory
• Cipher: AES-128-CTR
• MAC: keccak256 (mnemonic) / HMAC-SHA256 (admin keys)
• Timing-safe: Constant-time comparison

Mount Security

noexec      # Prevent executable files
nosuid      # Ignore setuid bits
nodev       # Ignore device files
umask=077   # Owner-only permissions
sync,flush  # Immediate write-through

Environment Variables

Optional Dependencies

For full functionality on all chains, install these optional packages:

# Bitcoin address generation
npm install bitcoinjs-lib tiny-secp256k1 ecpair

# Solana key derivation
npm install @solana/web3.js ed25519-hd-key bip39

# Monero address generation
npm install monero-javascript

Without these packages, the skill will:

• Still derive valid private keys
• Show hash160/partial addresses with notes about missing libraries
• Work fully for Ethereum and EVM chains (uses ethers.js)

File Structure

/mnt/floppy/
  .keystore/
    mnemonic-keystore.json   # Encrypted BIP-39 mnemonic (all chains)
    admin-keystore.json      # Single admin key (optional)

Troubleshooting

"Floppy not mounted"

# Check if device exists
ls -la /dev/sde

# Mount manually
sudo mount -t vfat /dev/sde /mnt/floppy -o noexec,nosuid,nodev,umask=077

"Unknown chain"

# List supported chains
node cli.js chains

# Use alias
node cli.js derive btc   # Same as 'bitcoin'
node cli.js derive eth   # Same as 'ethereum'

Missing addresses for Bitcoin/Solana/Monero

Install the optional dependencies for full address generation:

npm install bitcoinjs-lib tiny-secp256k1 ecpair  # Bitcoin
npm install @solana/web3.js ed25519-hd-key       # Solana

x402 Protocol Support

The floppy keystore fully supports the x402 payment protocol for HTTP-native payments.

Supported x402 Networks

Making x402 Payments

const { preparePayment } = require('./scripts/x402');
const { loadMnemonicFromFloppy } = require('./scripts/loader');

// Load mnemonic from floppy
const mnemonic = await loadMnemonicFromFloppy();

// Prepare payment for Base network
const payment = await preparePayment({
  network: 'eip155:8453',
  payTo: '0x1234...recipient',
  amount: '0.50',  // 0.50 USDC
  resource: 'https://api.example.com/data',
  mnemonic
});

// Use in HTTP request
const response = await fetch('https://api.example.com/data', {
  headers: {
    'X-PAYMENT': payment.header
  }
});

EIP-3009 Signing (EVM/Base)

For EVM networks, x402 uses EIP-3009 transferWithAuthorization:

const { createEVMPaymentPayload, encodePaymentHeader } = require('./scripts/x402');
const { deriveChainKeys } = require('./scripts/loader');

// Get Ethereum keys from floppy
const keys = await deriveChainKeys('ethereum', { count: 1 });
const wallet = keys[0];

// Create payment payload
const payload = await createEVMPaymentPayload({
  network: 'eip155:8453',  // Base mainnet
  payTo: '0x1234...merchant',
  amount: '1.00',
  privateKey: wallet.privateKey,
  fromAddress: wallet.address
});

// Encode for header
const header = encodePaymentHeader(payload);

Solana Payments

const { createSolanaPaymentPayload } = require('./scripts/x402');
const { deriveChainKeys } = require('./scripts/loader');

// Get Solana keys from floppy
const keys = await deriveChainKeys('solana', { count: 1 });

const payload = await createSolanaPaymentPayload({
  network: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
  payTo: 'Merchant...base58',
  amount: '2.00',
  privateKey: keys[0].privateKey,
  fromAddress: keys[0].address
});

Payment Tracking

Payments are automatically tracked in persistent memory:

const { getPaymentHistory, trackPayment } = require('./scripts/x402');

// Get payment history
const history = getPaymentHistory({ network: 'eip155:8453', limit: 10 });

// Manual tracking
trackPayment({
  network: 'eip155:8453',
  amount: '1.00',
  to: '0x...',
  resource: 'https://api.example.com',
  status: 'completed'
});

x402 Protocol Flow

1. Client requests protected resource
2. Server responds: 402 Payment Required + PAYMENT-REQUIRED header
3. Client decodes payment requirements
4. Client creates payment payload (EIP-3009 or SPL transfer)
5. Client signs with floppy keystore keys
6. Client retries with X-PAYMENT header
7. Facilitator verifies and settles payment
8. Server returns resource

Additional Documentation

• REFERENCE.md - Full API documentation
• HARDHAT-INTEGRATION.md - Hardhat configuration guide

Agent Identity & Persistent Memory

The floppy disk has ~1.4 MB available after keystores for storing agent identity and memory.

Storage Capacity

node cli.js storage
# Capacity:  1.4 MB
# Used:      1.2 KB (0.1%)
# Available: 1.43 MB

DID Document

Create and manage a W3C DID document for your agent:

# Create DID
node cli.js did create --method=key

# View DID document
node cli.js did show

# Add service endpoint
node cli.js did add-service --type=AgentService --endpoint=https://agent.example.com

AT Protocol (Bluesky) DID Support

Create DID documents compatible with the AT Protocol (Bluesky, etc.):

# Create AT Protocol DID (did:web)
node cli.js did atproto --domain=agent.example.com --handle=agent.bsky.social --pds=https://bsky.social

# Set signing key from keystore
node cli.js did setkey

# Validate for AT Protocol
node cli.js did validate

# Export for web hosting
node cli.js did export --file=did.json
# Host at: https://agent.example.com/.well-known/did.json

# Update handle
node cli.js did handle --handle=newhandle.bsky.social

AT Protocol DID Requirements:

• did:web or did:plc method
• alsoKnownAs with at:// handle URI
• Multikey verification method with secp256k1 key
• AtprotoPersonalDataServer service endpoint

// Programmatic usage
const identity = require('./scripts/identity');

// Create AT Protocol DID
const doc = identity.createATProtoDIDDocument({
  domain: 'agent.example.com',
  handle: 'agent.bsky.social',
  pdsUrl: 'https://bsky.social'
});

// Set public key from Ethereum-derived key
identity.setATProtoPublicKey(publicKeyHex);

// Validate
const result = identity.validateATProtoDID();
if (result.valid) {
  const json = identity.exportDIDForWeb();
  // Host json at /.well-known/did.json
}

ENS DID Support (did:ens)

For Ethereum ecosystem identity using ENS domains:

# Create ENS-based DID
node cli.js did ens --name=chipprbots.eth

# Export for ENS text record
node cli.js did export-ens
# Copy the output and add as "did" text record in ENS app

Important: did:ens is NOT supported by AT Protocol (Bluesky). Use did:web for Bluesky compatibility.

// Programmatic usage
const doc = identity.createENSDIDDocument({
  ensName: 'chipprbots.eth',
  chainId: '1'  // Ethereum mainnet
});

// Export for ENS storage
const { textRecord, instructions } = identity.exportDIDForENS();
// Store textRecord in ENS "did" text record

ENS vs AT Protocol DIDs:

Agent Profile

Store agent identity information:

# Set profile (interactive)
node cli.js profile set

# Set profile with options
node cli.js profile set --name="TradingAgent" --version="1.0.0"

# View profile
node cli.js profile show

Persistent Memory

Store notes, facts, and context that persist across sessions:

# Add memory
node cli.js memory add --content="User prefers BTC over ETH" --tags=preference --importance=8

# List memories
node cli.js memory list

# Search
node cli.js memory search --text="preference"

# Filter by importance
node cli.js memory list --importance=7

# Delete
node cli.js memory delete --id=abc123

Key-Value Metadata

Simple key-value store for configuration:

# Set value
node cli.js metadata set --key=lastSync --value="2025-01-15T10:00:00Z"

# Get value
node cli.js metadata get --key=lastSync

# List all
node cli.js metadata list

Programmatic Usage

const identity = require('./scripts/identity');

// DID Document
const did = identity.createDIDDocument({ method: 'key' });
console.log(did.id);  // did:key:abc123...

// Memory
identity.addMemory({
  type: 'fact',
  content: 'User wallet is 0x123...',
  tags: ['user', 'wallet'],
  importance: 9
});

const memories = identity.searchMemory({ tags: ['user'], limit: 5 });

// Metadata
identity.setMetadataValue('config.theme', 'dark');
const theme = identity.getMetadataValue('config.theme');

Security Best Practices

1. Physical security - Store floppy in secure location
2. Strong password - Use 16+ characters
3. Unmount immediately - Don't leave mounted
4. Never share mnemonic - One mnemonic = all chains
5. Test before production - Verify addresses on testnets first