@propxchain/core-client 0.2.1 → 0.3.0-canary.24

package/src/canisters/document_storage/document_storage.did.d.ts

@@ -2,10 +2,15 @@ import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
 import type { IDL } from '@dfinity/candid';
 
+export type ActorType = { 'agent' : null } |
+  { 'systemActor' : null } |
+  { 'user' : null };
 export interface AuditLog {
   'id' : bigint,
   'action' : string,
+  'actorType' : ActorType,
   'metadata' : string,
+  'delegatedBy' : [] | [Principal],
   'timestamp' : Time,
   'success' : boolean,
   'documentId' : bigint,
@@ -14,23 +19,52 @@ export interface AuditLog {
 export interface DocumentProof {
   'id' : bigint,
   'verified' : boolean,
+  'uploadedChunks' : bigint,
   'contentType' : string,
+  'titleNumber' : [] | [string],
   'fileHash' : string,
   'fileName' : string,
   'fileSize' : bigint,
+  'documentSource' : DocumentSource,
+  'totalChunks' : bigint,
+  'fetchedFromApi' : boolean,
+  'apiCostPence' : [] | [bigint],
+  'landRegistryReference' : [] | [string],
   'storageLocation' : string,
   'docType' : string,
   'uploadedAt' : Time,
   'uploadedBy' : Principal,
+  'validUntil' : [] | [bigint],
   'transactionId' : [] | [string],
 }
+export type DocumentSource = { 'UserUploaded' : null } |
+  { 'LandRegistryAPI' : null } |
+  { 'LandRegistryNotification' : null } |
+  { 'SystemGenerated' : null };
 export type Result = { 'ok' : boolean } |
   { 'err' : string };
-export type Result_1 = { 'ok' : string } |
+export type Result_1 = {
+    'ok' : {
+      'uploadedChunks' : bigint,
+      'totalChunks' : bigint,
+      'isComplete' : boolean,
+    }
+  } |
+  { 'err' : string };
+export type Result_2 = { 'ok' : string } |
   { 'err' : string };
-export type Result_2 = { 'ok' : bigint } |
+export type Result_3 = { 'ok' : bigint } |
   { 'err' : string };
-export type Result_3 = {
+export type Result_4 = {
+    'ok' : {
+      'uploadedChunks' : bigint,
+      'totalChunks' : bigint,
+      'missingChunks' : Array<bigint>,
+      'isComplete' : boolean,
+    }
+  } |
+  { 'err' : string };
+export type Result_5 = {
     'ok' : {
       'id' : bigint,
       'contentType' : string,
@@ -45,15 +79,34 @@ export type Result_3 = {
     }
   } |
   { 'err' : string };
+export type Result_6 = { 'ok' : Uint8Array | number[] } |
+  { 'err' : string };
 export type Time = bigint;
 export interface _SERVICE {
-  'deleteDocument' : ActorMethod<[bigint, string], Result_1>,
+  'deleteDocument' : ActorMethod<[bigint, string], Result_2>,
+  'downloadDocumentChunk' : ActorMethod<[bigint, bigint], Result_6>,
   'generateCSRFToken' : ActorMethod<[], string>,
   'getAuditLogs' : ActorMethod<[bigint], Array<AuditLog>>,
   'getCSRFToken' : ActorMethod<[], [] | [string]>,
   'getCycles' : ActorMethod<[], bigint>,
-  'getDocumentMetadata' : ActorMethod<[bigint], Result_3>,
+  'getDocumentByLandRegistryReference' : ActorMethod<
+    [string],
+    [] | [DocumentProof]
+  >,
+  'getDocumentMetadata' : ActorMethod<[bigint], Result_5>,
   'getDocumentProof' : ActorMethod<[bigint], [] | [DocumentProof]>,
+  'getDocumentUploadStatus' : ActorMethod<[bigint], Result_4>,
+  'getDocumentVerificationCanister' : ActorMethod<[], [] | [Principal]>,
+  'getExpiredLandRegistryDocuments' : ActorMethod<[], Array<DocumentProof>>,
+  'getLandRegistryCanister' : ActorMethod<[], [] | [Principal]>,
+  'getLandRegistryDocumentsForTitle' : ActorMethod<
+    [string],
+    Array<DocumentProof>
+  >,
+  'getLandRegistryDocumentsForTransaction' : ActorMethod<
+    [string],
+    Array<DocumentProof>
+  >,
   'getMyAuditLogs' : ActorMethod<[Principal], Array<AuditLog>>,
   'getRecentAuditLogs' : ActorMethod<[bigint], Array<AuditLog>>,
   'getStorageStats' : ActorMethod<
@@ -68,13 +121,37 @@ export interface _SERVICE {
   'getTransactionDocuments' : ActorMethod<[string], Array<DocumentProof>>,
   'getTransactionManagerCanister' : ActorMethod<[], [] | [Principal]>,
   'getUserManagementCanister' : ActorMethod<[], [] | [Principal]>,
-  'markDocumentDeleted' : ActorMethod<[bigint, string], Result_1>,
+  'markDocumentDeleted' : ActorMethod<[bigint, string], Result_2>,
+  'recordAuditEntry' : ActorMethod<
+    [ActorType, [] | [Principal], string, bigint, boolean, string],
+    Result_3
+  >,
   'registerDocumentProof' : ActorMethod<
     [string, string, bigint, string, string, [] | [string], string, string],
-    Result_2
+    Result_3
+  >,
+  'registerLandRegistryDocument' : ActorMethod<
+    [
+      string,
+      string,
+      string,
+      string,
+      bigint,
+      string,
+      string,
+      [] | [bigint],
+      bigint,
+    ],
+    Result_3
+  >,
+  'setDocumentVerificationCanister' : ActorMethod<[Principal], Result_2>,
+  'setLandRegistryCanister' : ActorMethod<[Principal], Result_2>,
+  'setTransactionManagerCanister' : ActorMethod<[Principal, string], Result_2>,
+  'setUserManagementCanister' : ActorMethod<[Principal, string], Result_2>,
+  'uploadDocumentChunk' : ActorMethod<
+    [bigint, bigint, Uint8Array | number[], string],
+    Result_1
   >,
-  'setTransactionManagerCanister' : ActorMethod<[Principal, string], Result_1>,
-  'setUserManagementCanister' : ActorMethod<[Principal, string], Result_1>,
   'validateCSRFToken' : ActorMethod<[string], boolean>,
   'verifyDocumentHash' : ActorMethod<[bigint, string, string], Result>,
 }

package/src/canisters/document_storage/document_storage.did.js

@@ -1,16 +1,51 @@
 export const idlFactory = ({ IDL }) => {
-  const Result_1 = IDL.Variant({ 'ok' : IDL.Text, 'err' : IDL.Text });
+  const Result_2 = IDL.Variant({ 'ok' : IDL.Text, 'err' : IDL.Text });
+  const Result_6 = IDL.Variant({ 'ok' : IDL.Vec(IDL.Nat8), 'err' : IDL.Text });
+  const ActorType = IDL.Variant({
+    'agent' : IDL.Null,
+    'systemActor' : IDL.Null,
+    'user' : IDL.Null,
+  });
   const Time = IDL.Int;
   const AuditLog = IDL.Record({
     'id' : IDL.Nat,
     'action' : IDL.Text,
+    'actorType' : ActorType,
     'metadata' : IDL.Text,
+    'delegatedBy' : IDL.Opt(IDL.Principal),
     'timestamp' : Time,
     'success' : IDL.Bool,
     'documentId' : IDL.Nat,
     'actorPrincipal' : IDL.Principal,
   });
-  const Result_3 = IDL.Variant({
+  const DocumentSource = IDL.Variant({
+    'UserUploaded' : IDL.Null,
+    'LandRegistryAPI' : IDL.Null,
+    'LandRegistryNotification' : IDL.Null,
+    'SystemGenerated' : IDL.Null,
+  });
+  const DocumentProof = IDL.Record({
+    'id' : IDL.Nat,
+    'verified' : IDL.Bool,
+    'uploadedChunks' : IDL.Nat,
+    'contentType' : IDL.Text,
+    'titleNumber' : IDL.Opt(IDL.Text),
+    'fileHash' : IDL.Text,
+    'fileName' : IDL.Text,
+    'fileSize' : IDL.Nat,
+    'documentSource' : DocumentSource,
+    'totalChunks' : IDL.Nat,
+    'fetchedFromApi' : IDL.Bool,
+    'apiCostPence' : IDL.Opt(IDL.Nat),
+    'landRegistryReference' : IDL.Opt(IDL.Text),
+    'storageLocation' : IDL.Text,
+    'docType' : IDL.Text,
+    'uploadedAt' : Time,
+    'uploadedBy' : IDL.Principal,
+    'validUntil' : IDL.Opt(IDL.Int),
+    'transactionId' : IDL.Opt(IDL.Text),
+  });
+  const Result_5 = IDL.Variant({
     'ok' : IDL.Record({
       'id' : IDL.Nat,
       'contentType' : IDL.Text,
@@ -25,33 +60,69 @@ export const idlFactory = ({ IDL }) => {
     }),
     'err' : IDL.Text,
   });
-  const DocumentProof = IDL.Record({
-    'id' : IDL.Nat,
-    'verified' : IDL.Bool,
-    'contentType' : IDL.Text,
-    'fileHash' : IDL.Text,
-    'fileName' : IDL.Text,
-    'fileSize' : IDL.Nat,
-    'storageLocation' : IDL.Text,
-    'docType' : IDL.Text,
-    'uploadedAt' : Time,
-    'uploadedBy' : IDL.Principal,
-    'transactionId' : IDL.Opt(IDL.Text),
+  const Result_4 = IDL.Variant({
+    'ok' : IDL.Record({
+      'uploadedChunks' : IDL.Nat,
+      'totalChunks' : IDL.Nat,
+      'missingChunks' : IDL.Vec(IDL.Nat),
+      'isComplete' : IDL.Bool,
+    }),
+    'err' : IDL.Text,
+  });
+  const Result_3 = IDL.Variant({ 'ok' : IDL.Nat, 'err' : IDL.Text });
+  const Result_1 = IDL.Variant({
+    'ok' : IDL.Record({
+      'uploadedChunks' : IDL.Nat,
+      'totalChunks' : IDL.Nat,
+      'isComplete' : IDL.Bool,
+    }),
+    'err' : IDL.Text,
   });
-  const Result_2 = IDL.Variant({ 'ok' : IDL.Nat, 'err' : IDL.Text });
   const Result = IDL.Variant({ 'ok' : IDL.Bool, 'err' : IDL.Text });
   return IDL.Service({
-    'deleteDocument' : IDL.Func([IDL.Nat, IDL.Text], [Result_1], []),
+    'deleteDocument' : IDL.Func([IDL.Nat, IDL.Text], [Result_2], []),
+    'downloadDocumentChunk' : IDL.Func([IDL.Nat, IDL.Nat], [Result_6], []),
     'generateCSRFToken' : IDL.Func([], [IDL.Text], []),
     'getAuditLogs' : IDL.Func([IDL.Nat], [IDL.Vec(AuditLog)], ['query']),
     'getCSRFToken' : IDL.Func([], [IDL.Opt(IDL.Text)], ['query']),
     'getCycles' : IDL.Func([], [IDL.Nat], ['query']),
-    'getDocumentMetadata' : IDL.Func([IDL.Nat], [Result_3], ['query']),
+    'getDocumentByLandRegistryReference' : IDL.Func(
+        [IDL.Text],
+        [IDL.Opt(DocumentProof)],
+        ['query'],
+      ),
+    'getDocumentMetadata' : IDL.Func([IDL.Nat], [Result_5], ['query']),
     'getDocumentProof' : IDL.Func(
         [IDL.Nat],
         [IDL.Opt(DocumentProof)],
         ['query'],
       ),
+    'getDocumentUploadStatus' : IDL.Func([IDL.Nat], [Result_4], ['query']),
+    'getDocumentVerificationCanister' : IDL.Func(
+        [],
+        [IDL.Opt(IDL.Principal)],
+        ['query'],
+      ),
+    'getExpiredLandRegistryDocuments' : IDL.Func(
+        [],
+        [IDL.Vec(DocumentProof)],
+        ['query'],
+      ),
+    'getLandRegistryCanister' : IDL.Func(
+        [],
+        [IDL.Opt(IDL.Principal)],
+        ['query'],
+      ),
+    'getLandRegistryDocumentsForTitle' : IDL.Func(
+        [IDL.Text],
+        [IDL.Vec(DocumentProof)],
+        ['query'],
+      ),
+    'getLandRegistryDocumentsForTransaction' : IDL.Func(
+        [IDL.Text],
+        [IDL.Vec(DocumentProof)],
+        ['query'],
+      ),
     'getMyAuditLogs' : IDL.Func(
         [IDL.Principal],
         [IDL.Vec(AuditLog)],
@@ -85,7 +156,19 @@ export const idlFactory = ({ IDL }) => {
         [IDL.Opt(IDL.Principal)],
         ['query'],
       ),
-    'markDocumentDeleted' : IDL.Func([IDL.Nat, IDL.Text], [Result_1], []),
+    'markDocumentDeleted' : IDL.Func([IDL.Nat, IDL.Text], [Result_2], []),
+    'recordAuditEntry' : IDL.Func(
+        [
+          ActorType,
+          IDL.Opt(IDL.Principal),
+          IDL.Text,
+          IDL.Nat,
+          IDL.Bool,
+          IDL.Text,
+        ],
+        [Result_3],
+        [],
+      ),
     'registerDocumentProof' : IDL.Func(
         [
           IDL.Text,
@@ -97,16 +180,42 @@ export const idlFactory = ({ IDL }) => {
           IDL.Text,
           IDL.Text,
         ],
+        [Result_3],
+        [],
+      ),
+    'registerLandRegistryDocument' : IDL.Func(
+        [
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          IDL.Nat,
+          IDL.Text,
+          IDL.Text,
+          IDL.Opt(IDL.Int),
+          IDL.Nat,
+        ],
+        [Result_3],
+        [],
+      ),
+    'setDocumentVerificationCanister' : IDL.Func(
+        [IDL.Principal],
         [Result_2],
         [],
       ),
+    'setLandRegistryCanister' : IDL.Func([IDL.Principal], [Result_2], []),
     'setTransactionManagerCanister' : IDL.Func(
         [IDL.Principal, IDL.Text],
-        [Result_1],
+        [Result_2],
         [],
       ),
     'setUserManagementCanister' : IDL.Func(
         [IDL.Principal, IDL.Text],
+        [Result_2],
+        [],
+      ),
+    'uploadDocumentChunk' : IDL.Func(
+        [IDL.Nat, IDL.Nat, IDL.Vec(IDL.Nat8), IDL.Text],
         [Result_1],
         [],
       ),

package/src/canisters/document_verification/document_verification.did

@@ -3,15 +3,137 @@ type VerificationMethod =
    commercial_api: text;
    dvla_api;
    manual_solicitor;
+   oscar_ai: OscarVerificationDetails;
    passport_dcs;
    system_hash_only;
  };
+type TransactionVerificationSummary = 
+ record {
+   allDocumentsVerified: bool;
+   allLRDocumentsCurrent: bool;
+   daysUntilSearchExpiry: opt int;
+   expiredDocuments: nat;
+   hasOfficialSearch: bool;
+   lrDocuments: vec LRDocumentSummary;
+   missingDocuments: vec text;
+   officialSearchExpiry: opt int;
+   officialSearchValid: bool;
+   readyForCompletion: bool;
+   readyForExchange: bool;
+   readyForSubmission: bool;
+   titleNumber: text;
+   totalDocuments: nat;
+   transactionId: text;
+   unverifiedDocuments: nat;
+   verifiedDocuments: nat;
+ };
 type Time = int;
+type Result_4 = 
+ variant {
+   err: text;
+   ok: TransactionVerificationSummary;
+ };
+type Result_3 = 
+ variant {
+   err: text;
+   ok: nat;
+ };
+type Result_2 = 
+ variant {
+   err: text;
+   ok: OfficialCopyVerification;
+ };
+type Result_1 = 
+ variant {
+   err: text;
+   ok: OSCertificateVerification;
+ };
 type Result = 
  variant {
    err: text;
    ok: DocumentVerification;
  };
+type PriorityStatus = 
+ variant {
+   Active;
+   Expired;
+   ExpiringImminently;
+   Unknown;
+ };
+type OscarVerificationInput = 
+ record {
+   confidence: nat;
+   documentType: text;
+   extractedData: text;
+   issues: vec OscarIssue;
+   mismatches: vec DataMismatch;
+   requiresSolicitorReview: bool;
+ };
+type OscarVerificationDetails = 
+ record {
+   analysisTimestamp: Time;
+   confidence: nat;
+   documentType: text;
+   extractedData: text;
+   issues: vec OscarIssue;
+   mismatches: vec DataMismatch;
+   requiresSolicitorReview: bool;
+ };
+type OscarIssue = 
+ record {
+   code: text;
+   field: opt text;
+   message: text;
+   severity: variant {
+               error;
+               info;
+               warning;
+             };
+ };
+type OfficialCopyVerification = 
+ record {
+   copyType: LRDocumentType;
+   documentAge: nat;
+   hashVerified: bool;
+   isCurrent: bool;
+   issuedAt: int;
+   titleNumberMatches: bool;
+   verifiedAt: int;
+   verifiedBy: principal;
+ };
+type OSCertificateVerification = 
+ record {
+   advisoryEntries: vec text;
+   daysRemaining: opt int;
+   hashVerified: bool;
+   priorityExpiry: opt int;
+   priorityStatus: PriorityStatus;
+   registerChangedFlag: opt bool;
+   titleNumberMatches: bool;
+   verifiedAt: int;
+   verifiedBy: principal;
+ };
+type LRDocumentType = 
+ variant {
+   AP1Acknowledgement;
+   CompletionConfirmation;
+   LandChargesSearchK16;
+   LocalAuthoritySearch;
+   OfficialCopyRegister;
+   OfficialCopyTitlePlan;
+   OfficialSearchCertificate;
+   RegisterExtract;
+   RequisitionNotice;
+   SearchOfPartCertificate;
+ };
+type LRDocumentSummary = 
+ record {
+   documentType: LRDocumentType;
+   isCurrent: bool;
+   isVerified: bool;
+   landRegistryReference: opt text;
+   validUntil: opt int;
+ };
 type DocumentVerification = 
  record {
    calculatedHash: text;
@@ -45,9 +167,17 @@ type DocumentMetadata =
    uploadedAt: Time;
    uploadedBy: principal;
  };
+type DataMismatch = 
+ record {
+   expected: text;
+   field: text;
+   found: text;
+ };
 type AuditLog = 
  record {
    action: text;
+   actorType: ActorType;
+   delegatedBy: opt principal;
    details: text;
    documentId: nat;
    id: nat;
@@ -55,6 +185,12 @@ type AuditLog =
    success: bool;
    timestamp: Time;
  };
+type ActorType = 
+ variant {
+   agent;
+   systemActor;
+   user;
+ };
 service : {
   deleteDocument: (documentId: nat) -> (variant {
                                           err: text;
@@ -70,6 +206,8 @@ service : {
   getDocument: (id: nat) -> (opt DocumentMetadata) query;
   getDocumentVerifications: (documentId: nat) ->
    (vec DocumentVerification) query;
+  getOscarVerificationDetails: (verificationId: nat) ->
+   (opt OscarVerificationDetails) query;
   getPropertyDocuments: (propertyId: nat) -> (vec DocumentMetadata) query;
   getRecentAuditLogs: (limit: nat) -> (vec AuditLog) query;
   getStats: () ->
@@ -79,10 +217,16 @@ service : {
       totalVerifications: nat;
       verifiedDocuments: nat;
     }) query;
+  getTransactionVerificationSummary: (transactionId: text, titleNumber:
+   text) -> (Result_4);
   getUnverifiedDocuments: (propertyId: nat) -> (vec DocumentMetadata) query;
   getVerification: (verificationId: nat) -> (opt DocumentVerification) query;
+  getVerificationsByTransaction: (txId: nat) ->
+   (vec DocumentVerification) query;
   getVerificationsByVerifier: (verifier: principal) ->
    (vec DocumentVerification) query;
+  recordAuditEntry: (actorType: ActorType, delegatedBy: opt principal,
+   action: text, documentId: nat, details: text, success: bool) -> (Result_3);
   registerDocument: (propertyId: nat, transactionId: opt nat, documentType:
    text, documentHash: text, storageDocumentId: opt nat, fileName: opt text,
    fileSize: opt nat, contentType: opt text) -> (nat);
@@ -90,9 +234,15 @@ service : {
   setUserManagementCanister: (canisterId: principal) -> ();
   verifyDocument: (documentId: nat) -> (bool);
   verifyDocumentWithHash: (documentId: nat, notes: opt text) -> (Result);
+  verifyOfficialCopy: (documentId: nat, expectedTitleNumber: text,
+   maxAgeDays: nat) -> (Result_2);
+  verifyOfficialSearchCertificate: (documentId: nat, expectedTitleNumber:
+   text, _expectedTransactionId: opt text) -> (Result_1);
   verifyWithCommercialAPI: (_documentId: nat, _apiProvider: text,
    _verificationData: text) -> (Result);
   verifyWithDVLA: (_documentId: nat, _drivingLicenseNumber: text) -> (Result);
+  verifyWithOscar: (documentId: nat, oscarResult: OscarVerificationInput) ->
+   (Result);
   verifyWithPassportDCS: (_documentId: nat, _passportNumber: text) ->
    (Result);
 }