@solidus-network/types

npm install @solidus-network/types

import type {
  DID,
  DIDDocument,
  VerifiableCredential,
  Challenge,
  VerificationSession,
} from '@solidus-network/types'

interface DID {
  id: string          // e.g. "did:solidus:testnet:7Kf9xB2..."
  controller: string  // DID of the controller (usually same as id)
  created: string     // ISO 8601 creation timestamp
  updated: string     // ISO 8601 last-update timestamp
  network: string     // "testnet" or "mainnet"
}

interface VerificationMethod {
  id: string                    // e.g. "did:solidus:testnet:7Kf9...#key-1"
  type: 'Ed25519VerificationKey2020'
  controller: string            // The DID that controls this key
  publicKeyMultibase: string    // Multibase-encoded Ed25519 public key
}

interface DIDDocument {
  '@context': string | string[]
  id: string                              // The DID
  verificationMethod: VerificationMethod[] // Public keys
  authentication: string[]                // Key refs for authentication
  assertionMethod: string[]               // Key refs for signing credentials
}

type KYCLevel = 0 | 1 | 2 | 3

type VerificationStatus =
  | 'pending'
  | 'processing'
  | 'completed'
  | 'failed'
  | 'expired'

interface CredentialProof {
  type: 'Ed25519Signature2020'
  created: string              // ISO 8601 timestamp
  verificationMethod: string   // DID key reference (e.g. "did:solidus:...#key-1")
  proofPurpose: string         // "assertionMethod" for credentials
  proofValue: string           // Base58-encoded Ed25519 signature
}

interface VerifiableCredential {
  '@context': string | string[]
  id: string                           // URN UUID (e.g. "urn:uuid:a1b2c3d4-...")
  type: string[]                       // e.g. ["VerifiableCredential", "KYCCredential"]
  issuer: string                       // Issuer DID
  issuanceDate: string                 // ISO 8601 timestamp
  expirationDate?: string              // ISO 8601 timestamp (optional)
  credentialSubject: Record<string, unknown>  // The claims
  proof: CredentialProof               // Cryptographic proof
}

interface IssueCredentialParams {
  subjectDid: string           // DID of the credential subject
  issuerDid: string            // DID of the issuer
  issuerPrivateKey: string     // Hex-encoded Ed25519 private key
  type: string[]               // Credential types
  claims: Record<string, unknown>  // Claims to include
  expiresInDays?: number       // Days until expiration
  network?: string             // Network override
}

interface VerificationResult {
  valid: boolean               // Overall validity
  credentialId?: string        // The credential ID if resolved
  error?: string               // Error message if invalid
  checks: {
    signature: boolean         // Ed25519 signature is valid
    expiry: boolean            // Credential has not expired
    revocation: boolean        // Credential has not been revoked
  }
}

interface AuthResult {
  valid: boolean
  did?: string                 // The authenticated DID
  claims?: Record<string, unknown>  // Claims from the presentation
  error?: string               // Error message if invalid
}

interface Challenge {
  challenge: string   // The nonce value
  domain: string      // The domain that issued the challenge
  expiresAt: string   // ISO 8601 expiration timestamp
}

type SandboxOutcome =
  | 'pass'
  | 'fail'
  | 'timeout'
  | 'document_rejected'

interface VerificationSession {
  id: string                   // Session UUID
  organizationId: string       // Organization that created the session
  subjectDid?: string          // DID of the person being verified (set after linking)
  level: KYCLevel              // Required verification level
  status: VerificationStatus   // Current status
  credentialId?: string        // Credential ID (set after successful verification)
  sandbox: boolean             // Whether this is a sandbox session
  sandboxOutcome?: SandboxOutcome  // Forced outcome for sandbox sessions
  createdAt: string            // ISO 8601 creation timestamp
  updatedAt: string            // ISO 8601 last-update timestamp
}

import { createSdk } from '@solidus-network/sdk'
import type {
  DIDDocument,
  VerifiableCredential,
  VerificationResult,
} from '@solidus-network/types'
 
const sdk = createSdk({ mode: 'testnet', chain: { /* ... */ } })
 
// did.create returns DIDDocument
const doc: DIDDocument = await sdk.did.create(publicKeyHex)
 
// credentials.issue returns VerifiableCredential
const cred: VerifiableCredential = await sdk.credentials.issue({
  subjectDid: doc.id,
  issuerDid: 'did:solidus:testnet:issuer',
  issuerPrivateKey: '0x...',
  type: ['VerifiableCredential'],
  claims: { verified: true },
})
 
// credentials.verify returns VerificationResult
const result: VerificationResult = await sdk.credentials.verify(cred)