@proofchain/sdk 1.2.0 → 2.0.0

package/package.json

@@ -1,12 +1,7 @@
 {
   "name": "@proofchain/sdk",
-  "version": "1.2.0",
-  "description": "TypeScript SDK for the ProofChain Attestation Service API",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/clivewatts/attestify.git"
-  },
-  "homepage": "https://proofchain.co.za",
+  "version": "2.0.0",
+  "description": "Official JavaScript/TypeScript SDK for ProofChain - blockchain-anchored document attestation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -17,32 +12,61 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
-    "test": "vitest",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
+    "proofchain",
+    "blockchain",
     "attestation",
-    "merkle",
     "ipfs",
-    "web3",
-    "blockchain"
+    "proof",
+    "verification",
+    "documents",
+    "certificates",
+    "web3"
   ],
-  "author": "Clive Watts <MegaWatts Solutions>",
-  "license": "SEE LICENSE IN LICENSE",
-  "dependencies": {
-    "ethers": "^6.9.0"
+  "author": "ProofChain <support@proofchain.co.za>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/proofchain/proofchain-js.git"
+  },
+  "homepage": "https://proofchain.co.za",
+  "bugs": {
+    "url": "https://github.com/proofchain/proofchain-js/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
+    "eslint": "^8.55.0",
     "tsup": "^8.0.1",
-    "typescript": "^5.3.3",
-    "vitest": "^1.1.0"
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
   },
   "peerDependencies": {
-    "ethers": "^6.0.0"
+    "typescript": ">=4.7.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   }
 }

package/src/client.ts

@@ -1,312 +0,0 @@
-import type {
-  AttestationClientConfig,
-  RequestOptions,
-  HealthResponse,
-  ChallengeRequest,
-  ChallengeResponse,
-  VerifyRequest,
-  AuthResponse,
-  EventCreate,
-  Event,
-  EventsListResponse,
-  EventQuery,
-  MerkleTree,
-  MerkleProof,
-  VerifyProofRequest,
-  VerifyProofResponse,
-  LinkWalletRequest,
-  Wallet,
-  WalletStatus,
-  Quest,
-  QuestWithProgress,
-  UserQuestProgress,
-  QuestStepCompletionResult,
-} from './types';
-
-export class AttestationClientError extends Error {
-  constructor(
-    message: string,
-    public status: number,
-    public body?: unknown
-  ) {
-    super(message);
-    this.name = 'AttestationClientError';
-  }
-}
-
-export class AttestationClient {
-  private baseUrl: string;
-  private accessToken?: string;
-  private timeout: number;
-
-  constructor(config: AttestationClientConfig) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, '');
-    this.accessToken = config.accessToken;
-    this.timeout = config.timeout ?? 30000;
-  }
-
-  // ============ Internal Methods ============
-
-  private async request<T>(
-    method: string,
-    path: string,
-    body?: unknown,
-    options?: RequestOptions
-  ): Promise<T> {
-    const url = `${this.baseUrl}${path}`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      ...options?.headers,
-    };
-
-    if (this.accessToken) {
-      headers['Authorization'] = `Bearer ${this.accessToken}`;
-    }
-
-    try {
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : undefined,
-        signal: options?.signal ?? controller.signal,
-      });
-
-      clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        const errorBody = await response.json().catch(() => null);
-        throw new AttestationClientError(
-          `Request failed: ${response.status} ${response.statusText}`,
-          response.status,
-          errorBody
-        );
-      }
-
-      return response.json();
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof AttestationClientError) throw error;
-      throw new AttestationClientError(
-        `Request failed: ${(error as Error).message}`,
-        0
-      );
-    }
-  }
-
-  // ============ Auth Methods ============
-
-  setAccessToken(token: string): void {
-    this.accessToken = token;
-  }
-
-  clearAccessToken(): void {
-    this.accessToken = undefined;
-  }
-
-  // ============ Health ============
-
-  async health(): Promise<HealthResponse> {
-    return this.request<HealthResponse>('GET', '/health');
-  }
-
-  // ============ Authentication ============
-
-  async requestChallenge(walletAddress: string): Promise<ChallengeResponse> {
-    return this.request<ChallengeResponse>('POST', '/auth/web3/challenge', {
-      wallet_address: walletAddress,
-    } as ChallengeRequest);
-  }
-
-  async verifySignature(
-    walletAddress: string,
-    signature: string,
-    message: string
-  ): Promise<AuthResponse> {
-    const response = await this.request<AuthResponse>('POST', '/auth/web3/verify', {
-      wallet_address: walletAddress,
-      signature,
-      message,
-    } as VerifyRequest);
-
-    // Auto-set the access token
-    if (response.access_token) {
-      this.setAccessToken(response.access_token);
-    }
-
-    return response;
-  }
-
-  // ============ Events ============
-
-  async createEvent(event: EventCreate): Promise<Event> {
-    return this.request<Event>('POST', '/events', event);
-  }
-
-  async getEvents(
-    userId: string,
-    options?: {
-      limit?: number;
-      offset?: number;
-      eventType?: string;
-      fetchData?: boolean;
-    }
-  ): Promise<EventsListResponse> {
-    const params = new URLSearchParams();
-    if (options?.limit) params.set('limit', options.limit.toString());
-    if (options?.offset) params.set('offset', options.offset.toString());
-    if (options?.eventType) params.set('event_type', options.eventType);
-    if (options?.fetchData) params.set('fetch_data', 'true');
-
-    const query = params.toString();
-    return this.request<EventsListResponse>(
-      'GET',
-      `/data/events/${userId}${query ? `?${query}` : ''}`
-    );
-  }
-
-  async queryEvents(userId: string, query: EventQuery): Promise<EventsListResponse> {
-    return this.request<EventsListResponse>(
-      'POST',
-      `/data/events/${userId}/query`,
-      query
-    );
-  }
-
-  // ============ Merkle Tree ============
-
-  async rebuildMerkleTree(userId: string): Promise<MerkleTree> {
-    return this.request<MerkleTree>('POST', `/merkle/rebuild/${userId}`);
-  }
-
-  async getMerkleRoot(userId: string): Promise<MerkleTree> {
-    return this.request<MerkleTree>('GET', `/merkle/root/${userId}`);
-  }
-
-  async getMerkleProof(userId: string, ipfsHash: string): Promise<MerkleProof> {
-    return this.request<MerkleProof>('GET', `/merkle/proof/${userId}/${ipfsHash}`);
-  }
-
-  async verifyMerkleProof(
-    leaf: string,
-    proof: string[],
-    root: string
-  ): Promise<VerifyProofResponse> {
-    return this.request<VerifyProofResponse>('POST', '/merkle/verify', {
-      leaf,
-      proof,
-      root,
-    } as VerifyProofRequest);
-  }
-
-  // ============ Wallets ============
-
-  async linkWallet(request: LinkWalletRequest): Promise<Wallet> {
-    return this.request<Wallet>('POST', '/wallet/link', request);
-  }
-
-  async getWalletStatus(userId: string): Promise<WalletStatus> {
-    return this.request<WalletStatus>('GET', `/wallet/status/${userId}`);
-  }
-
-  // ============ Quests ============
-
-  /**
-   * List available quests for a user
-   * @param userId - End user external ID
-   * @param options - Filter options
-   */
-  async getAvailableQuests(
-    userId: string,
-    options?: { category?: string; limit?: number }
-  ): Promise<QuestWithProgress[]> {
-    const params = new URLSearchParams();
-    params.set('user_id', userId);
-    if (options?.category) params.set('category', options.category);
-    if (options?.limit) params.set('limit', options.limit.toString());
-    
-    return this.request<QuestWithProgress[]>(
-      'GET',
-      `/quests/available?${params.toString()}`
-    );
-  }
-
-  /**
-   * Get a specific quest by ID with all steps
-   * @param questId - Quest ID
-   */
-  async getQuest(questId: string): Promise<Quest> {
-    return this.request<Quest>('GET', `/quests/${questId}`);
-  }
-
-  /**
-   * Start a quest for a user
-   * @param questId - Quest ID
-   * @param userId - End user external ID
-   */
-  async startQuest(questId: string, userId: string): Promise<UserQuestProgress> {
-    return this.request<UserQuestProgress>(
-      'POST',
-      `/quests/${questId}/start?user_id=${encodeURIComponent(userId)}`,
-      {}
-    );
-  }
-
-  /**
-   * Get user's progress on a specific quest
-   * @param questId - Quest ID
-   * @param userId - End user external ID
-   */
-  async getQuestProgress(questId: string, userId: string): Promise<UserQuestProgress> {
-    return this.request<UserQuestProgress>(
-      'GET',
-      `/quests/${questId}/progress/${encodeURIComponent(userId)}`
-    );
-  }
-
-  /**
-   * Get all quest progress for a user
-   * @param userId - End user external ID
-   * @param status - Optional status filter
-   */
-  async getUserQuestProgress(
-    userId: string,
-    status?: string
-  ): Promise<UserQuestProgress[]> {
-    const params = new URLSearchParams();
-    if (status) params.set('status', status);
-    const query = params.toString();
-    
-    return this.request<UserQuestProgress[]>(
-      'GET',
-      `/quests/user/${encodeURIComponent(userId)}/progress${query ? `?${query}` : ''}`
-    );
-  }
-
-  /**
-   * Complete or increment a quest step
-   * @param questId - Quest ID
-   * @param userId - End user external ID
-   * @param stepIndex - Step index (0-based)
-   * @param options - Completion options
-   */
-  async completeQuestStep(
-    questId: string,
-    userId: string,
-    stepIndex: number,
-    options?: { count?: number; value?: string }
-  ): Promise<QuestStepCompletionResult> {
-    const params = new URLSearchParams();
-    if (options?.count) params.set('count', options.count.toString());
-    if (options?.value) params.set('value', options.value);
-    const query = params.toString();
-    
-    return this.request<QuestStepCompletionResult>(
-      'POST',
-      `/quests/${questId}/progress/${encodeURIComponent(userId)}/step/${stepIndex}/complete${query ? `?${query}` : ''}`,
-      {}
-    );
-  }
-}

package/src/contract.ts

@@ -1,212 +0,0 @@
-import { ethers, type Signer, type Provider, type ContractTransactionResponse } from 'ethers';
-
-// ABI for AttestationRegistry contract
-const ATTESTATION_REGISTRY_ABI = [
-  // Read functions
-  'function attestationRoots(address wallet) view returns (bytes32 merkleRoot, uint256 eventCount, uint256 lastUpdated, string latestIpfsHash)',
-  'function getRoot(address wallet) view returns (bytes32 root, uint256 eventCount, uint256 lastUpdated, string latestIpfsHash)',
-  'function getHistoryCount(address wallet) view returns (uint256 count)',
-  'function getHistoricalRoot(address wallet, uint256 index) view returns (bytes32 root, uint256 eventCount, uint256 timestamp)',
-  'function verifyAttestation(address wallet, bytes32 leaf, bytes32[] proof) view returns (bool valid)',
-  'function computeLeaf(string ipfsHash, string eventType, uint256 timestamp) pure returns (bytes32 leaf)',
-  'function getWalletByIpfsHash(string ipfsHash) view returns (address wallet)',
-  'function authorizedUpdaters(address) view returns (bool)',
-  'function owner() view returns (address)',
-
-  // Write functions
-  'function updateRoot(address wallet, bytes32 newRoot, uint256 eventCount, string latestIpfsHash)',
-  'function batchUpdateRoots(address[] wallets, bytes32[] roots, uint256[] eventCounts, string[] ipfsHashes)',
-  'function setAuthorizedUpdater(address updater, bool authorized)',
-
-  // Events
-  'event RootUpdated(address indexed wallet, bytes32 indexed newRoot, bytes32 indexed previousRoot, uint256 eventCount, string latestIpfsHash)',
-  'event AttestationVerified(address indexed wallet, bytes32 indexed leaf, string ipfsHash, bool valid)',
-  'event UpdaterAuthorized(address indexed updater, bool authorized)',
-];
-
-export interface AttestationRoot {
-  merkleRoot: string;
-  eventCount: bigint;
-  lastUpdated: bigint;
-  latestIpfsHash: string;
-}
-
-export interface RootHistory {
-  merkleRoot: string;
-  eventCount: bigint;
-  timestamp: bigint;
-}
-
-export interface RootUpdatedEvent {
-  wallet: string;
-  newRoot: string;
-  previousRoot: string;
-  eventCount: bigint;
-  latestIpfsHash: string;
-}
-
-export class AttestationRegistryContract {
-  private contract: ethers.Contract;
-  private signer?: Signer;
-
-  constructor(
-    contractAddress: string,
-    signerOrProvider: Signer | Provider
-  ) {
-    this.contract = new ethers.Contract(
-      contractAddress,
-      ATTESTATION_REGISTRY_ABI,
-      signerOrProvider
-    );
-
-    if ('getAddress' in signerOrProvider) {
-      this.signer = signerOrProvider as Signer;
-    }
-  }
-
-  // ============ Read Functions ============
-
-  async getRoot(wallet: string): Promise<AttestationRoot> {
-    const [merkleRoot, eventCount, lastUpdated, latestIpfsHash] = 
-      await this.contract.getRoot(wallet);
-    return {
-      merkleRoot,
-      eventCount,
-      lastUpdated,
-      latestIpfsHash,
-    };
-  }
-
-  async getHistoryCount(wallet: string): Promise<bigint> {
-    return this.contract.getHistoryCount(wallet);
-  }
-
-  async getHistoricalRoot(wallet: string, index: number): Promise<RootHistory> {
-    const [merkleRoot, eventCount, timestamp] = 
-      await this.contract.getHistoricalRoot(wallet, index);
-    return { merkleRoot, eventCount, timestamp };
-  }
-
-  async verifyAttestation(
-    wallet: string,
-    leaf: string,
-    proof: string[]
-  ): Promise<boolean> {
-    return this.contract.verifyAttestation(wallet, leaf, proof);
-  }
-
-  async computeLeaf(
-    ipfsHash: string,
-    eventType: string,
-    timestamp: number
-  ): Promise<string> {
-    return this.contract.computeLeaf(ipfsHash, eventType, timestamp);
-  }
-
-  async getWalletByIpfsHash(ipfsHash: string): Promise<string> {
-    return this.contract.getWalletByIpfsHash(ipfsHash);
-  }
-
-  async isAuthorizedUpdater(address: string): Promise<boolean> {
-    return this.contract.authorizedUpdaters(address);
-  }
-
-  async owner(): Promise<string> {
-    return this.contract.owner();
-  }
-
-  // ============ Write Functions ============
-
-  async updateRoot(
-    wallet: string,
-    newRoot: string,
-    eventCount: number,
-    latestIpfsHash: string
-  ): Promise<ContractTransactionResponse> {
-    if (!this.signer) {
-      throw new Error('Signer required for write operations');
-    }
-    return this.contract.updateRoot(wallet, newRoot, eventCount, latestIpfsHash);
-  }
-
-  async batchUpdateRoots(
-    wallets: string[],
-    roots: string[],
-    eventCounts: number[],
-    ipfsHashes: string[]
-  ): Promise<ContractTransactionResponse> {
-    if (!this.signer) {
-      throw new Error('Signer required for write operations');
-    }
-    return this.contract.batchUpdateRoots(wallets, roots, eventCounts, ipfsHashes);
-  }
-
-  async setAuthorizedUpdater(
-    updater: string,
-    authorized: boolean
-  ): Promise<ContractTransactionResponse> {
-    if (!this.signer) {
-      throw new Error('Signer required for write operations');
-    }
-    return this.contract.setAuthorizedUpdater(updater, authorized);
-  }
-
-  // ============ Event Listeners ============
-
-  onRootUpdated(
-    callback: (event: RootUpdatedEvent) => void,
-    filter?: { wallet?: string }
-  ): void {
-    const eventFilter = this.contract.filters.RootUpdated(filter?.wallet);
-    this.contract.on(eventFilter, (wallet, newRoot, previousRoot, eventCount, latestIpfsHash) => {
-      callback({
-        wallet,
-        newRoot,
-        previousRoot,
-        eventCount,
-        latestIpfsHash,
-      });
-    });
-  }
-
-  removeAllListeners(): void {
-    this.contract.removeAllListeners();
-  }
-
-  // ============ Utilities ============
-
-  static computeLeafOffchain(
-    ipfsHash: string,
-    eventType: string,
-    timestamp: number
-  ): string {
-    return ethers.keccak256(
-      ethers.solidityPacked(
-        ['string', 'string', 'uint256'],
-        [ipfsHash, eventType, timestamp]
-      )
-    );
-  }
-
-  static verifyProofOffchain(
-    leaf: string,
-    proof: string[],
-    root: string
-  ): boolean {
-    let computedHash = leaf;
-
-    for (const proofElement of proof) {
-      if (computedHash < proofElement) {
-        computedHash = ethers.keccak256(
-          ethers.solidityPacked(['bytes32', 'bytes32'], [computedHash, proofElement])
-        );
-      } else {
-        computedHash = ethers.keccak256(
-          ethers.solidityPacked(['bytes32', 'bytes32'], [proofElement, computedHash])
-        );
-      }
-    }
-
-    return computedHash === root;
-  }
-}

package/src/index.ts

@@ -1,65 +0,0 @@
-/**
- * Copyright (c) 2024-2025 Clive Watts / MegaWatts Solutions
- * All Rights Reserved.
- *
- * PROPRIETARY AND CONFIDENTIAL
- * This software is the exclusive property of MegaWatts Solutions.
- * Unauthorized copying, distribution, or use is strictly prohibited.
- * See LICENSE file for full terms.
- */
-
-// Client
-export { AttestationClient, AttestationClientError } from './client';
-
-// Contract
-export { 
-  AttestationRegistryContract,
-  type AttestationRoot,
-  type RootHistory,
-  type RootUpdatedEvent,
-} from './contract';
-
-// Types
-export type {
-  // Config
-  AttestationClientConfig,
-  RequestOptions,
-  
-  // Requests
-  ChallengeRequest,
-  VerifyRequest,
-  EventCreate,
-  EventQuery,
-  VerifyProofRequest,
-  LinkWalletRequest,
-  
-  // Responses
-  HealthResponse,
-  ChallengeResponse,
-  AuthResponse,
-  Event,
-  EventsListResponse,
-  MerkleTree,
-  MerkleProof,
-  VerifyProofResponse,
-  Wallet,
-  WalletStatus,
-  
-  // Quests
-  Quest,
-  QuestStep,
-  QuestWithProgress,
-  UserQuestProgress,
-  QuestStepCompletionResult,
-  RewardInfo,
-} from './types';
-
-// Convenience factory
-import { AttestationClient as Client } from './client';
-
-export function createClient(baseUrl: string, accessToken?: string): Client {
-  return new Client({
-    baseUrl,
-    accessToken,
-  });
-}