03. RealSeal

Real-Seal

Real-Seal provides document and text signing with blockchain verification, enabling tamper-proof digital signatures with public/private sharing.

Overview

Purpose: Sign and verify documents and texts using blockchain-anchored cryptographic signatures.

Key Features:

• Upload and sign PDF, Word, images, and other documents

• Sign text content and URLs

• Blockchain anchoring for tamper-proof verification

• Share signed documents with specific addresses

• Create public verification links

Location: src/packages/real-seal/

---

Documents

Upload Document

Upload a document to Real-Seal for signing.

Endpoint: POST /real-seal/documents/

Authentication: Required (JWT)

Request:

import { axiosInstance } from '@/packages/real-seal/api/axiosInstance'

export const uploadDocument = async (file: File, title?: string) => {
  const formData = new FormData()
  formData.append('file', file)
  if (title) formData.append('title', title)

  const response = await axiosInstance.post<DocumentUploadResponse>(
    '/real-seal/documents/',
    formData
  )
  return response.data
}

Request Body: FormData

• file (required): Document file

• title (optional): Custom title for the document

Supported File Types:

• PDF: .pdf

• Word: .doc, .docx

• Excel: .xls, .xlsx

• Images: .jpg, .jpeg, .png, .gif, .webp

• Text: .txt, .md

• Archives: .zip

File Size Limit: Check configuration via GET /real-seal/config

Response:

interface DocumentUploadResponse {
  document_id: string
  title?: string
  filename: string
  mimetype: string
  content_length: number
  file_hash: string
  visibility: string
  created_at: string
}

Example Response:

{
  "document_id": "123e4567-e89b-12d3-a456-426614174000",
  "title": "Contract Agreement",
  "filename": "contract.pdf",
  "mimetype": "application/pdf",
  "content_length": 524288,
  "file_hash": "0x7f8a9b3c...",
  "visibility": "private",
  "created_at": "2025-01-15T10:30:00Z"
}

Usage:

import { useMutation } from '@tanstack/react-query'

function DocumentUpload() {
  const uploadMutation = useMutation({
    mutationFn: ({ file, title }: { file: File; title?: string }) =>
      uploadDocument(file, title),
    onSuccess: (data) => {
      toast.success('Document uploaded!')
      navigate(`/real-seal/documents/${data.uuid}`)
    }
  })

  const handleUpload = (file: File) => {
    uploadMutation.mutate({ file })
  }

  return <FileDropzone onDrop={handleUpload} />
}

---

Get Document Metadata

Fetch metadata for a specific document.

Endpoint: GET /real-seal/documents/{id}

Authentication: Required (JWT)

Parameters:

• id (path): Document UUID

Implementation:

export const getDocumentMetadata = async (id: string) => {
  const response = await axiosInstance.get<DocumentMetadata>(
    `/real-seal/documents/${id}`
  )
  return response.data
}

Response: DocumentMetadata object (see Upload Document)

Access Control:

• Owner can always access

• Shared addresses can access if in authorized_addresses

• Public access only if public_enabled: true

---

Download Document

Download the actual document file.

Endpoint: GET /real-seal/documents/{id}/download

Authentication: Required (JWT)

Parameters:

• id (path): Document UUID

Implementation:

export const downloadDocument = async (id: string) => {
  const response = await axiosInstance.get<Blob>(
    `/real-seal/documents/${id}/download`,
    { responseType: 'blob' }
  )
  return response.data
}

Response: File blob with original content type

Usage:

function DownloadButton({ documentId }: { documentId: string }) {
  const downloadMutation = useMutation({
    mutationFn: () => downloadDocument(documentId),
    onSuccess: async (blob, variables) => {
      // Get filename from metadata
      const metadata = await getDocumentMetadata(documentId)

      // Create download link
      const url = URL.createObjectURL(blob)
      const a = document.createElement('a')
      a.href = url
      a.download = metadata.filename
      a.click()
      URL.revokeObjectURL(url)
    }
  })

  return (
    <button onClick={() => downloadMutation.mutate()}>
      Download
    </button>
  )
}

---

List User Documents

List all documents owned by or shared with the authenticated user.

Endpoint: GET /real-seal/documents?with_shared_addresses=true

Authentication: Required (JWT)

Implementation:

export const listUserDocuments = async () => {
  const response = await axiosInstance.get<DocumentListResponse>(
    '/real-seal/documents',
    { params: { with_shared_addresses: true } }
  )
  return response.data
}

Response:

interface DocumentListResponse {
  documents: DocumentMetadata[]
  total_count: number
}

Usage:

function DocumentList() {
  const { data, isLoading } = useQuery({
    queryKey: ['real-seal', 'documents', 'user'],
    queryFn: listUserDocuments
  })

  if (isLoading) return <div>Loading...</div>

  return (
    <div>
      <p>Total: {data.total_count}</p>
      {data.documents.map(doc => (
        <DocumentCard key={doc.uuid} document={doc} />
      ))}
    </div>
  )
}

---

List Documents with Filters

List documents with advanced filtering options.

Endpoint: GET /real-seal/documents?scope=owned&...

Authentication: Required (JWT)

Query Parameters:

• scope (optional): 'owned' or 'shared'

• start_date (optional): ISO 8601 date string

• end_date (optional): ISO 8601 date string

• min_size (optional): Minimum file size in bytes

• max_size (optional): Maximum file size in bytes

• file_format (optional): MIME type filter

• search (optional): Search in filename/title

Implementation:

interface DocumentFilters {
  scope?: 'owned' | 'shared'
  start_date?: string
  end_date?: string
  min_size?: number
  max_size?: number
  file_format?: string
  search?: string
}

export const listDocumentsByScope = async (filters: DocumentFilters) => {
  const response = await axiosInstance.get<DocumentListResponse>(
    '/real-seal/documents',
    { params: filters }
  )
  return response.data
}

Example Usage:

// Get only owned PDFs from last month
const filters = {
  scope: 'owned',
  start_date: '2025-01-01T00:00:00Z',
  file_format: 'application/pdf'
}

const { data } = useQuery({
  queryKey: ['real-seal', 'documents', 'user', 'owned', filters],
  queryFn: () => listDocumentsByScope(filters)
})

---

Sign Document

Sign a document with a blockchain-anchored cryptographic signature.

Endpoint: POST /real-seal/documents/{id}/sign

Authentication: Required (JWT)

Parameters:

• id (path): Document UUID

Request:

interface SignDocumentRequest {
  file_hash: string // Blake2 hash of file content
  signature: string // Wallet signature of the signing message
  timestamp: string // Unix timestamp (seconds)
}

export const signDocument = async (id: string, data: SignDocumentRequest) => {
  const response = await axiosInstance.post<DocumentMetadata>(
    `/real-seal/documents/${id}/sign`,
    data
  )
  return response.data
}

Request Body:

{
  "file_hash": "0x7f8a9b3c...",
  "signature": "0xabc123...",
  "timestamp": "1705320600"
}

Response: Updated DocumentMetadata with signature

Signature Process:

1. Download document and calculate Blake2 hash

2. Construct signing message: REAL_SEAL::SIGN_DOCUMENT::${documentHash}::${timestamp}

3. Sign the message with wallet

4. Submit signature, hash, and timestamp to backend

5. Backend verifies signature matches owner and message

6. Document marked as signed

Implementation:

import { blake2AsHex } from '@polkadot/util-crypto'
import { encodeAddress } from '@polkadot/util-crypto'

async function signDocumentFlow(documentId: string) {
  // 1. Download document
  const blob = await downloadDocument(documentId)
  const arrayBuffer = await blob.arrayBuffer()
  const uint8Array = new Uint8Array(arrayBuffer)

  // 2. Calculate hash
  const fileHash = blake2AsHex(uint8Array)

  // 3. Construct message and sign
  const timestamp = Math.floor(Date.now() / 1000).toString()
  const signingMessage = `REAL_SEAL::SIGN_DOCUMENT::${fileHash}::${timestamp}`

  const signerResult = await getSigner() // Use useSigner hook

  const signatureResult = await signerResult.signer.signRaw({
    address: encodeAddress(currentAccount.address, 355),
    data: signingMessage,
    type: 'bytes'
  })

  // 4. Submit signature
  await signDocument(documentId, {
    file_hash: fileHash,
    signature: signatureResult.signature,
    timestamp
  })

  toast.success('Document signed!')
}

---

Verify Document Signature

Verify that a document's signature is valid and hasn't been tampered with.

Endpoint: GET /real-seal/documents/{id}/verify

Authentication: Not required for public documents

Parameters:

• id (path): Document UUID

Implementation:

export const verifyDocumentSignature = async (id: string) => {
  const response = await axiosInstance.get<VerificationResponse>(
    `/real-seal/documents/${id}/verify`
  )
  return response.data
}

Response:

interface VerificationResponse {
  valid: boolean
  signature: DocumentSignature | null
  on_chain_verified: boolean
  message?: string
}

interface DocumentSignature {
  signer_address: string
  signature: string
  signed_at: string
  signed_message: string
}

Example Response:

{
  "valid": true,
  "signature": {
    "signer_address": "g6x...",
    "signature": "0xabc123...",
    "signed_at": "2025-01-15T10:30:00Z",
    "signed_message": "0x7f8a9b3c..."
  },
  "on_chain_verified": true
}

Usage:

function VerificationBadge({ documentId }: { documentId: string }) {
  const { data: verification } = useQuery({
    queryKey: ['real-seal', 'documents', documentId, 'verification'],
    queryFn: () => verifyDocumentSignature(documentId)
  })

  if (!verification?.valid) {
    return <Badge variant="destructive">Invalid Signature</Badge>
  }

  return (
    <Badge variant="success">
      ✓ Verified {verification.on_chain_verified && '(On-Chain)'}
    </Badge>
  )
}

---

Share Document

Share a document with specific Gen6 addresses.

Endpoint: POST /real-seal/documents/{id}/share

Authentication: Required (JWT - must be owner)

Parameters:

• id (path): Document UUID

Request:

interface ShareRequest {
  addresses?: string[] // SS58-355 encoded addresses
}

export const shareDocument = async (id: string, addresses?: string[]) => {
  const response = await axiosInstance.post<DocumentMetadata>(
    `/real-seal/documents/${id}/share`,
    { addresses }
  )
  return response.data
}

Request Body:

{
  "addresses": ["g6x123...", "g6x456..."]
}

Response: Updated DocumentMetadata with authorized_addresses

Behavior:

• If addresses is empty/undefined, shares with everyone

• If addresses has values, shares only with those addresses

• Replaces existing share list (not additive)

Usage:

function ShareDocumentDialog({ documentId }: { documentId: string }) {
  const [addresses, setAddresses] = useState<string[]>([])

  const shareMutation = useMutation({
    mutationFn: () => shareDocument(documentId, addresses),
    onSuccess: () => toast.success('Document shared!')
  })

  return (
    <Dialog>
      <Input
        placeholder="Enter Gen6 addresses..."
        onChange={(e) => setAddresses(e.target.value.split(','))}
      />
      <Button onClick={() => shareMutation.mutate()}>
        Share
      </Button>
    </Dialog>
  )
}

---

Unshare Document

Revoke document access for specific addresses.

Endpoint: DELETE /real-seal/documents/{id}/share

Authentication: Required (JWT - must be owner)

Parameters:

• id (path): Document UUID

Request:

interface UnshareRequest {
  addresses: string[] // Addresses to revoke
}

export const unshareDocument = async (id: string, addresses: string[]) => {
  const response = await axiosInstance.delete<DocumentMetadata>(
    `/real-seal/documents/${id}/share`,
    { data: { addresses } }
  )
  return response.data
}

Request Body:

{
  "addresses": ["g6x123..."]
}

Response: Updated DocumentMetadata

---

Create Public Link

Generate a public link for document verification without authentication.

Endpoint: POST /real-seal/documents/{id}/public

Authentication: Required (JWT - must be owner)

Parameters:

• id (path): Document UUID

Implementation:

export const createPublicLink = async (id: string) => {
  const response = await axiosInstance.post<PublicLinkResponse>(
    `/real-seal/documents/${id}/public`
  )
  return response.data
}

Response:

interface PublicLinkResponse {
  public_url: string
  created_at: string
}

Example Response:

{
  "public_url": "https://app.gen6.com/real-seal/public/abc123def456",
  "created_at": "2025-01-15T10:30:00Z"
}

Usage:

function CreatePublicLinkButton({ documentId }: { documentId: string }) {
  const createMutation = useMutation({
    mutationFn: () => createPublicLink(documentId),
    onSuccess: (data) => {
      navigator.clipboard.writeText(data.public_url)
      toast.success('Public link copied!')
    }
  })

  return (
    <Button onClick={() => createMutation.mutate()}>
      Create Public Link
    </Button>
  )
}

---

Revoke Public Link

Disable public access to a document.

Endpoint: DELETE /real-seal/documents/{id}/public

Authentication: Required (JWT - must be owner)

Parameters:

• id (path): Document UUID

Implementation:

export const revokePublicLink = async (id: string) => {
  const response = await axiosInstance.delete<DocumentMetadata>(
    `/real-seal/documents/${id}/public`
  )
  return response.data
}

Response: Updated DocumentMetadata with public_enabled: false

---

Get Public Link

Retrieve the current public link for a document (if enabled).

Endpoint: GET /real-seal/documents/{id}/public

Authentication: Required (JWT - must be owner)

Parameters:

• id (path): Document UUID

Implementation:

export const getPublicLink = async (id: string) => {
  const response = await axiosInstance.get<PublicLinkResponse>(
    `/real-seal/documents/${id}/public`
  )
  return response.data
}

Response: PublicLinkResponse or 404 if not enabled

---

Delete Document

Permanently delete a document.

Endpoint: DELETE /real-seal/documents/{id}

Authentication: Required (JWT - must be owner)

Parameters:

• id (path): Document UUID

Implementation:

export const deleteDocument = async (id: string) => {
  await axiosInstance.delete(`/real-seal/documents/${id}`)
}

Response: 204 No Content

Warning: This action is permanent and cannot be undone.

Usage:

function DeleteDocumentButton({ documentId }: { documentId: string }) {
  const deleteMutation = useMutation({
    mutationFn: () => deleteDocument(documentId),
    onSuccess: () => {
      toast.success('Document deleted')
      navigate('/real-seal/documents')
    }
  })

  return (
    <AlertDialog>
      <AlertDialogTrigger asChild>
        <Button variant="destructive">Delete</Button>
      </AlertDialogTrigger>
      <AlertDialogContent>
        <AlertDialogTitle>Are you sure?</AlertDialogTitle>
        <AlertDialogDescription>
          This action cannot be undone.
        </AlertDialogDescription>
        <AlertDialogFooter>
          <AlertDialogCancel>Cancel</AlertDialogCancel>
          <AlertDialogAction onClick={() => deleteMutation.mutate()}>
            Delete
          </AlertDialogAction>
        </AlertDialogFooter>
      </AlertDialogContent>
    </AlertDialog>
  )
}

---

Public Document Access

Get Public Document Metadata

Access document metadata via public token (no authentication required).

Endpoint: GET /real-seal/public/{token}/metadata

Authentication: Not required

Parameters:

• token (path): Public access token from public URL

Implementation:

export const getPublicDocumentMetadataByToken = async (token: string) => {
  const response = await axiosInstance.get<DocumentMetadata>(
    `/real-seal/public/${token}/metadata`
  )
  return response.data
}

Response: DocumentMetadata object

Usage:

// From public URL: https://app.gen6.com/real-seal/public/abc123def456
const token = 'abc123def456'

function PublicDocumentPage({ token }: { token: string }) {
  const { data: metadata } = useQuery({
    queryKey: ['real-seal', 'public', token],
    queryFn: () => getPublicDocumentMetadataByToken(token)
  })

  return (
    <div>
      <h1>{metadata.title || metadata.filename}</h1>
      <p>Signed by: {metadata.signature?.signer_address}</p>
    </div>
  )
}

---

Download Public Document

Download document via public token (no authentication required).

Endpoint: GET /real-seal/public/{token}/download

Authentication: Not required

Parameters:

• token (path): Public access token

Implementation:

export const downloadPublicDocumentByToken = async (token: string) => {
  const response = await axiosInstance.get<Blob>(
    `/real-seal/public/${token}/download`,
    { responseType: 'blob' }
  )
  return response.data
}

Response: File blob

---

Text Signing

Create Text to Sign

Create a text or URL entry for signing.

Endpoint: POST /real-seal/texts/

Authentication: Required (JWT)

Request:

interface CreateTextRequest {
  content: string
  type: 'text' | 'url'
  title?: string
}

export const createTextSign = async (data: CreateTextRequest) => {
  const response = await axiosInstance.post<TextMetadata>(
    '/real-seal/texts/',
    data
  )
  return response.data
}

Request Body:

{
  "content": "I hereby agree to the terms...",
  "type": "text",
  "title": "Agreement"
}

Response:

interface TextMetadata {
  uuid: string
  title: string | null
  content: string
  type: 'text' | 'url'
  content_hash: string // Blake2 hash of content
  visibility: string
  owner_address: string
  signature: TextSignature | null
  created_at: string
  updated_at: string
  authorized_addresses: string[]
  public_enabled: boolean
  public_created_at: string | null
}

interface TextSignature {
  signer_address: string
  signature: string
  signed_at: string
  signed_message: string
}

---

Get Text Metadata

Fetch metadata for a specific text entry.

Endpoint: GET /real-seal/texts/{id}

Authentication: Required (JWT)

Parameters:

• id (path): Text UUID

Implementation:

export const getTextMetadata = async (id: string) => {
  const response = await axiosInstance.get<TextMetadata>(
    `/real-seal/texts/${id}`
  )
  return response.data
}

Response: TextMetadata object

---

Sign Text

Sign a text entry with a cryptographic signature.

Endpoint: POST /real-seal/texts/{id}/sign

Authentication: Required (JWT)

Parameters:

• id (path): Text UUID

Request:

interface SignTextRequest {
  content_hash: string // Blake2 hash of content
  signature: string // Wallet signature
  timestamp: string // ISO 8601
}

export const signText = async (id: string, data: SignTextRequest) => {
  const response = await axiosInstance.post<TextMetadata>(
    `/real-seal/texts/${id}/sign`,
    data
  )
  return response.data
}

Signing Process:

import { blake2AsHex } from '@polkadot/util-crypto'
import { stringToU8a } from '@polkadot/util'
import { web3FromAddress } from '@polkadot/extension-dapp'

async function signTextFlow(textId: string, content: string) {
  // 1. Calculate hash
  const contentHash = blake2AsHex(stringToU8a(content))

  // 2. Sign hash
  const injector = await web3FromAddress(currentAccount.address)
  const signatureResult = await injector.signer.signRaw({
    address: currentAccount.address,
    data: contentHash,
    type: 'bytes'
  })

  // 3. Submit signature
  const timestamp = new Date().toISOString()
  await signText(textId, {
    content_hash: contentHash,
    signature: signatureResult.signature,
    timestamp
  })

  toast.success('Text signed!')
}

---

Create and Sign Text (Single Call)

Create and sign a text in one API call.

Endpoint: POST /real-seal/texts/sign

Authentication: Required (JWT)

Request:

interface CreateAndSignTextRequest {
  content: string
  type: 'text' | 'url'
  title?: string
  signature: string
  timestamp: string
}

export const createAndSignText = async (data: CreateAndSignTextRequest) => {
  const response = await axiosInstance.post<TextMetadata>(
    '/real-seal/texts/sign',
    data
  )
  return response.data
}

Usage: Convenience method to avoid separate create + sign calls.

---

List Text Entries

List text entries with optional filters.

Endpoint: GET /real-seal/texts/

Authentication: Required (JWT)

Query Parameters:

• scope: 'owned' or 'shared'

• type: 'text' or 'url'

• start_date, end_date: Date range

• search: Search in content/title

Implementation:

export const listTextSigns = async (filters?: {
  scope?: 'owned' | 'shared'
  type?: 'text' | 'url'
  start_date?: string
  end_date?: string
  search?: string
}) => {
  const response = await axiosInstance.get<TextListResponse>(
    '/real-seal/texts/',
    { params: filters }
  )
  return response.data
}

Response:

interface TextListResponse {
  texts: TextMetadata[]
  total_count: number
}

---

Delete Text

Delete a text entry.

Endpoint: DELETE /real-seal/texts/{id}

Authentication: Required (JWT - must be owner)

Parameters:

• id (path): Text UUID

Implementation:

export const deleteTextSign = async (id: string) => {
  await axiosInstance.delete(`/real-seal/texts/${id}`)
}

---

Text Sharing & Public Links

Text entries support the same sharing and public link features as documents:

• POST /real-seal/texts/{id}/share - Share with addresses

• DELETE /real-seal/texts/{id}/share - Revoke sharing

• POST /real-seal/texts/{id}/public - Create public link

• DELETE /real-seal/texts/{id}/public - Revoke public link

• GET /real-seal/texts/{id}/public - Get public link

APIs identical to document endpoints (see above).

---

Query Account Balance

Check account balance for transaction fee estimation.

Blockchain Query: api.query.system.account()

Parameters:

• address: SS58-355 encoded account address

Implementation:

// Used in upload-document-modal.tsx for fee estimation
const balance = await api.query.system.account(currentAccount.address)
const accountData = balance.toJSON()
const freeBalance = accountData.data.free

Response: Account info including free balance for fee calculation

Usage: Automatically checked before document upload to ensure sufficient balance for blockchain transactions.

---

Blockchain Integration

Store Document Hash On-Chain

Anchor the document hash on the blockchain for immutable verification.

Extrinsic: api.tx.dataRegistry.storeData()

Parameters:

• projectId: 886 (Real-Seal project ID)

• dataHash: Blake2 hash of document content

Implementation:

import { useGen6 } from '@/contexts/gen6-context'
import { useSigner } from '@/hooks/useSigner'

export function useRealSeal() {
  const { api, currentAccount } = useGen6()
  const { getSigner } = useSigner()

  const storeDocumentHash = async (fileHash: string) => {
    const signerResult = await getSigner()

    const extrinsic = api.tx.dataRegistry.storeData(
      886, // Project ID for Real-Seal
      fileHash // Blake2 hash
    )

    return new Promise<void>((resolve, reject) => {
      extrinsic
        .signAndSend(
          currentAccount.address,
          { signer: signerResult.signer },
          ({ status, dispatchError }) => {
            if (status.isFinalized) {
              if (dispatchError) {
                reject(new Error('Transaction failed'))
              } else {
                resolve()
              }
            }
          }
        )
        .catch(reject)
    })
  }

  return { storeDocumentHash }
}

Complete Signing Flow:

async function completeSigningFlow(documentId: string) {
  // 1. Download and hash document
  const blob = await downloadDocument(documentId)
  const arrayBuffer = await blob.arrayBuffer()
  const uint8Array = new Uint8Array(arrayBuffer)
  const fileHash = blake2AsHex(uint8Array)

  // 2. Sign hash with wallet
  const injector = await web3FromAddress(currentAccount.address)
  const signatureResult = await injector.signer.signRaw({
    address: currentAccount.address,
    data: fileHash,
    type: 'bytes'
  })

  // 3. Store hash on blockchain
  await storeDocumentHash(fileHash)

  // 4. Submit signature to backend
  const timestamp = new Date().toISOString()
  await signDocument(documentId, {
    file_hash: fileHash,
    signature: signatureResult.signature,
    timestamp
  })

  toast.success('Document signed and verified on blockchain!')
}

---

Configuration

Get Real-Seal Config

Retrieve Real-Seal configuration (e.g., max file size).

Endpoint: GET /real-seal/config

Authentication: Not required

Implementation:

export const getRealSealConfig = async () => {
  const response = await axiosInstance.get<RealSealConfig>('/real-seal/config')
  return response.data
}

Response:

interface RealSealConfig {
  max_file_size: number // In bytes
  allowed_mimetypes: string[]
}

Example Response:

{
  "max_file_size": 10485760,
  "allowed_mimetypes": [
    "application/pdf",
    "application/msword",
    "image/jpeg",
    "image/png"
  ]
}

---

Query Keys

TanStack Query Keys:

const realSealKeys = {
  all: ['real-seal'] as const,
  documents: () => [...realSealKeys.all, 'documents'] as const,
  document: (id: string) => [...realSealKeys.documents(), id] as const,
  userDocuments: () => [...realSealKeys.documents(), 'user'] as const,
  userDocumentsOwned: (filters) =>
    [...realSealKeys.userDocuments(), 'owned', filters] as const,
  userDocumentsShared: (filters) =>
    [...realSealKeys.userDocuments(), 'shared', filters] as const,
  verification: (id: string) =>
    [...realSealKeys.document(id), 'verification'] as const,
  publicDocument: (token: string) =>
    [...realSealKeys.all, 'public', token] as const,
  texts: () => [...realSealKeys.all, 'texts'] as const,
  text: (id: string) => [...realSealKeys.texts(), id] as const
}

---

Next Steps

• Ncrypt - Send encrypted messages

• Identity - Link signed documents to verified identities