Stellar SDK Reference

npm install @attestprotocol/stellar-sdk @stellar/stellar-sdk

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

const client = new StellarAttestationClient({
  rpcUrl: string,           // Soroban RPC URL
  network: 'testnet' | 'mainnet',
  publicKey: string,        // Your Stellar public key
  contractId?: string,      // Optional: custom contract ID
  allowHttp?: boolean       // Allow HTTP (dev only)
});

await client.createSchema({
  definition: string,      // Schema definition: "name:string,verified:bool"
  revocable?: boolean,     // Default: true
  resolver?: string,       // Optional resolver contract address
  options?: { signer, simulate }
})

await client.attest({
  schemaUid: Buffer,       // 32-byte schema identifier
  value: string,           // JSON-encoded attestation data
  subject?: string,        // Who the attestation is about (defaults to caller)
  expirationTime?: number, // Unix timestamp when attestation expires
  options?: { signer, simulate }
})

await client.revoke({
  attestationUid: Buffer,  // 32-byte attestation UID
  options?: { signer, simulate }
})

const schema = await client.getSchema(uid: Buffer)

const attestation = await client.getAttestation(uid: Buffer)

const schemas = await client.fetchSchemas(limit?: number) // Max 100

const attestations = await client.fetchAttestations(limit?: number) // Max 100

const { schemas, total, hasMore } = await client.fetchSchemasByWallet({
  walletAddress: string,
  limit?: number
})

const { attestations, total, hasMore } = await client.fetchAttestationsByWallet({
  walletAddress: string,
  limit?: number
})

const schemas = await client.getSchemasByLedger(ledger: number, limit?: number)

const attestations = await client.getAttestationsByLedger(ledger: number, limit?: number)

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

const encoder = new SorobanSchemaEncoder({
  name: 'KYCVerification',
  fields: [
    { name: 'verified', type: 'bool' },
    { name: 'level', type: 'string' },
    { name: 'timestamp', type: 'u64' }
  ]
});

// Encode data for attestation
const payload = await encoder.encodeData({
  verified: true,
  level: 'premium',
  timestamp: Date.now()
});

// Decode attestation value
const decoded = await encoder.decodeData(attestation.value);

const xdrString = client.encodeSchema({ name: 'TestSchema', fields: [...] })

const schema = client.decodeSchema('XDR:AAAAB...')

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

await client.registerBlsKey(publicKey: Buffer, options?: { signer })

const blsKey = await client.getBlsKey(attester?: string)

await client.attestByDelegation({
  attester: string,
  schema_uid: Buffer,
  subject: string,
  value: string,
  nonce: bigint,
  deadline: bigint,
  expiration_time: bigint | undefined,
  signature: Buffer
}, options?: { signer })

await client.revokeByDelegation({
  attestation_uid: Buffer,
  schema_uid: Buffer,
  subject: string,
  revoker: string,
  nonce: bigint,
  deadline: bigint,
  signature: Buffer
}, options?: { signer })

import {
  createDelegatedAttestationRequest,
  createDelegatedRevocationRequest,
  createAttestMessage,
  createRevokeMessage,
  signHashedMessage,
  verifySignature
} from '@attestprotocol/stellar-sdk';

// Create complete delegated attestation request
const request = await createDelegatedAttestationRequest({
  schemaUid: Buffer.from('abc...', 'hex'),
  subject: 'GSUBJECT...',
  data: JSON.stringify({ verified: true })
}, blsPrivateKey, client.getClientInstance());

// Sign a message
const dst = await client.getAttestDST();
const messagePoint = createAttestMessage(request, dst);
const signature = signHashedMessage(messagePoint, privateKey);

// Verify signature
const result = verifySignature({
  signature: signatureBuffer,
  expectedMessage: messagePoint,
  publicKey: publicKeyBuffer
});

const uid = client.generateSchemaUid({
  definition: string,
  authority: string,
  resolver?: string
})

const uid = client.generateAttestationUid({
  schemaUid: Buffer,
  subject: string,
  nonce: bigint
})

import { getSchemaByUid, getAttestationByUid, fetchRegistryDump } from '@attestprotocol/stellar-sdk';

// Fetch schema by UID
const schema = await getSchemaByUid('abc123...', true, 'testnet');

// Fetch attestation by UID
const attestation = await getAttestationByUid('def456...', 'testnet');

// Fetch complete registry dump
const dump = await fetchRegistryDump('testnet');

const result = await client.submitTransaction(signedXdr: string, {
  skipSimulation?: boolean
})

const protocolClient = client.getClientInstance()

const server = client.getServerInstance()

interface ClientOptions {
  rpcUrl: string;
  network: 'testnet' | 'mainnet';
  publicKey: string;
  contractId?: string;
  networkPassphrase?: string;
  allowHttp?: boolean;
}

interface TxOptions {
  signer?: TransactionSigner;
  simulate?: boolean;
  timeoutInSeconds?: number;
}

interface TransactionSigner {
  signTransaction(xdr: string): Promise<string>;
}

interface ContractSchema {
  uid: Buffer;
  definition: string;
  authority: string;
  resolver: string;
  revocable: boolean;
  timestamp: number;
}

interface ContractAttestation {
  uid: Buffer;
  schemaUid: Buffer;
  subject: string;
  attester: string;
  value: any;
  timestamp: number;
  expirationTime?: number;
  revocationTime?: number;
  revoked: boolean;
}

interface BlsKeyPair {
  privateKey: Buffer;  // 32 bytes
  publicKey: Buffer;   // 192 bytes uncompressed
}

// Main client
export { StellarAttestationClient } from '@attestprotocol/stellar-sdk';

// Service classes
export { StellarSchemaRegistry, AttestProtocolAuthority };

// Schema encoding
export { SorobanSchemaEncoder, encodeSchema, decodeSchema, createSimpleSchema };

// UID generation
export { generateAttestationUid, generateSchemaUid };

// BLS delegation
export { generateBlsKeys, signHashedMessage, verifySignature };
export { createDelegatedAttestationRequest, createDelegatedRevocationRequest };
export { createAttestMessage, createRevokeMessage };

// Indexer API
export { getSchemaByUid, getAttestationByUid, fetchRegistryDump };

// Error classes
export { ContractError, NetworkError, ConfigurationError };