Delegates

┌─────────────────────┐          ┌─────────────────────┐
│      Authority      │          │      Delegate       │
│  (BLS private key)  │          │  (Stellar wallet)   │
└─────────────────────┘          └─────────────────────┘
         │                                │
         │ 1. Sign attestation            │
         │    data off-chain              │
         ▼                                │
┌─────────────────────┐                   │
│   BLS Signature     │───────────────────▶
└─────────────────────┘  2. Submit with   │
                            signature     │
                                          ▼
                              ┌─────────────────────┐
                              │    Smart Contract   │
                              │  Verifies signature │
                              │  Creates attestation│
                              └─────────────────────┘

// Example: Authority signs, delegate submits
const request = await createDelegatedAttestationRequest({
  schemaUid: Buffer.from('abc123...', 'hex'),
  subject: 'GUSER123...',  // The person receiving the attestation
  data: JSON.stringify({ verified: true })
}, blsPrivateKey, client.getClientInstance());

// When submitted by delegate:
// attestation.attester = 'GDELEGATE...' (who submitted)
// attestation.subject = 'GUSER123...' (who the attestation is about)

// Authority acts as their own delegate
const authority = new StellarAttestationClient({
  rpcUrl: 'https://soroban-testnet.stellar.org',
  network: 'testnet',
  publicKey: 'GAUTHORITY...'
});

// Sign the request
const request = await createDelegatedAttestationRequest({
  schemaUid: Buffer.from('abc...', 'hex'),
  subject: 'GSUBJECT...',
  data: JSON.stringify({ verified: true })
}, blsPrivateKey, authority.getClientInstance());

// Submit as self (authority is the delegate)
const result = await authority.attestByDelegation(request, {
  signer: authoritySigner
});

// Result: attester = authority, subject = GSUBJECT

import { generateBlsKeys } from '@attestprotocol/stellar-sdk';

const { publicKey, privateKey } = generateBlsKeys();
// publicKey: 192 bytes (uncompressed)
// privateKey: 32 bytes

await client.registerBlsKey(publicKey, { signer });

import { createDelegatedAttestationRequest } from '@attestprotocol/stellar-sdk';

// Authority signs off-chain
const request = await createDelegatedAttestationRequest({
  schemaUid: Buffer.from('abc123...', 'hex'),
  subject: 'GSUBJECT...',
  data: JSON.stringify({ verified: true }),
  expirationTime: Math.floor(Date.now() / 1000) + 86400 // 24h
}, blsPrivateKey, client.getClientInstance());

// Delegate submits the pre-signed request
await client.attestByDelegation(request, { signer: delegateSigner });

import { createDelegatedRevocationRequest } from '@attestprotocol/stellar-sdk';

// Authority signs revocation
const revokeRequest = await createDelegatedRevocationRequest({
  attestationUid: Buffer.from('def456...', 'hex')
}, blsPrivateKey, client.getClientInstance());

// Delegate submits
await client.revokeByDelegation(revokeRequest, { signer: delegateSigner });

Authority ─┬─ Sign 1000 attestations ─▶ Queue ─▶ Worker 1 ─▶ Submit
           │                                   ─▶ Worker 2 ─▶ Submit
           │                                   ─▶ Worker 3 ─▶ Submit

import {
  StellarAttestationClient,
  generateBlsKeys,
  createDelegatedAttestationRequest
} from '@attestprotocol/stellar-sdk';

// Setup
const authority = new StellarAttestationClient({
  rpcUrl: 'https://soroban-testnet.stellar.org',
  network: 'testnet',
  publicKey: 'GAUTHORITY...'
});

// One-time: Generate and register BLS keys
const { publicKey, privateKey } = generateBlsKeys();
await authority.registerBlsKey(publicKey, { signer: authoritySigner });

// Authority signs attestation request
const request = await createDelegatedAttestationRequest({
  schemaUid: Buffer.from('abc...', 'hex'),
  subject: 'GSUBJECT...',
  data: JSON.stringify({ verified: true, level: 'premium' })
}, privateKey, authority.getClientInstance());

// Delegate submits (can be different wallet or same as authority)
const delegate = new StellarAttestationClient({
  rpcUrl: 'https://soroban-testnet.stellar.org',
  network: 'testnet',
  publicKey: 'GDELEGATE...'
});

const result = await delegate.attestByDelegation(request, {
  signer: delegateSigner
});