@propxchain/core-client 0.1.0 → 0.2.0-canary.7

package/src/canisters/property_registry/property_registry.did

@@ -0,0 +1,78 @@
+type Time = int;
+type Result_3 = 
+ variant {
+   err: text;
+   ok: vec text;
+ };
+type Result_2 = 
+ variant {
+   err: text;
+   ok: text;
+ };
+type Result_1 = 
+ variant {
+   err: text;
+   ok: ChainPropertyView;
+ };
+type Result = 
+ variant {
+   err: text;
+   ok;
+ };
+type PropertyStatus = 
+ variant {
+   Cancelled;
+   Completed;
+   InTransaction;
+   Listed;
+ };
+type Property = 
+ record {
+   address: text;
+   anonymousPropertyId: text;
+   chainPosition: opt nat;
+   createdAt: Time;
+   description: text;
+   documentsComplete: bool;
+   financingComplete: bool;
+   id: nat;
+   isVerified: bool;
+   linkedProperties: vec text;
+   owner: principal;
+   price: nat;
+   propertyType: text;
+   searchesComplete: bool;
+   size: nat;
+   status: PropertyStatus;
+   transactionId: opt text;
+ };
+type ChainPropertyView = 
+ record {
+   anonymousId: text;
+   documentsComplete: bool;
+   financingComplete: bool;
+   progressPercentage: nat;
+   role: text;
+   searchesComplete: bool;
+   status: PropertyStatus;
+ };
+service : {
+  buildPropertyChain: (rootPropertyId: text) -> (Result_3);
+  canViewFullPropertyDetails: (propertyId: text, requesterId: principal) ->
+   (bool) query;
+  generateAnonymousPropertyId: (propertyId: text) -> (Result_2);
+  getAllProperties: () -> (vec Property) query;
+  getCycles: () -> (nat) query;
+  getProperty: (id: nat) -> (opt Property) query;
+  getPropertyForChainView: (propertyId: text, requesterId: principal) ->
+   (Result_1) query;
+  registerProperty: (address: text, price: nat, size: nat, propertyType:
+   text, description: text) -> (nat);
+  transferOwnership: (propertyId: nat, newOwner: principal) -> (bool);
+  updatePropertyProgress: (propertyId: nat, documentsComplete: bool,
+   searchesComplete: bool, financingComplete: bool) -> (Result);
+  updatePropertyStatus: (propertyId: nat, status: PropertyStatus) -> (Result);
+  updatePropertyTransaction: (propertyId: nat, transactionId: opt text,
+   chainPosition: opt nat, linkedProperties: vec text) -> (Result);
+  verifyProperty: (id: nat) -> (bool);
+}

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

@@ -0,0 +1,71 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
+
+export interface ChainPropertyView {
+  'status' : PropertyStatus,
+  'progressPercentage' : bigint,
+  'role' : string,
+  'documentsComplete' : boolean,
+  'financingComplete' : boolean,
+  'searchesComplete' : boolean,
+  'anonymousId' : string,
+}
+export interface Property {
+  'id' : bigint,
+  'anonymousPropertyId' : string,
+  'status' : PropertyStatus,
+  'propertyType' : string,
+  'owner' : Principal,
+  'createdAt' : Time,
+  'size' : bigint,
+  'documentsComplete' : boolean,
+  'description' : string,
+  'isVerified' : boolean,
+  'linkedProperties' : Array<string>,
+  'address' : string,
+  'chainPosition' : [] | [bigint],
+  'financingComplete' : boolean,
+  'price' : bigint,
+  'searchesComplete' : boolean,
+  'transactionId' : [] | [string],
+}
+export type PropertyStatus = { 'Listed' : null } |
+  { 'InTransaction' : null } |
+  { 'Cancelled' : null } |
+  { 'Completed' : null };
+export type Result = { 'ok' : null } |
+  { 'err' : string };
+export type Result_1 = { 'ok' : ChainPropertyView } |
+  { 'err' : string };
+export type Result_2 = { 'ok' : string } |
+  { 'err' : string };
+export type Result_3 = { 'ok' : Array<string> } |
+  { 'err' : string };
+export type Time = bigint;
+export interface _SERVICE {
+  'buildPropertyChain' : ActorMethod<[string], Result_3>,
+  'canViewFullPropertyDetails' : ActorMethod<[string, Principal], boolean>,
+  'generateAnonymousPropertyId' : ActorMethod<[string], Result_2>,
+  'getAllProperties' : ActorMethod<[], Array<Property>>,
+  'getCycles' : ActorMethod<[], bigint>,
+  'getProperty' : ActorMethod<[bigint], [] | [Property]>,
+  'getPropertyForChainView' : ActorMethod<[string, Principal], Result_1>,
+  'registerProperty' : ActorMethod<
+    [string, bigint, bigint, string, string],
+    bigint
+  >,
+  'transferOwnership' : ActorMethod<[bigint, Principal], boolean>,
+  'updatePropertyProgress' : ActorMethod<
+    [bigint, boolean, boolean, boolean],
+    Result
+  >,
+  'updatePropertyStatus' : ActorMethod<[bigint, PropertyStatus], Result>,
+  'updatePropertyTransaction' : ActorMethod<
+    [bigint, [] | [string], [] | [bigint], Array<string>],
+    Result
+  >,
+  'verifyProperty' : ActorMethod<[bigint], boolean>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/src/canisters/property_registry/property_registry.did.js

@@ -0,0 +1,77 @@
+export const idlFactory = ({ IDL }) => {
+  const Result_3 = IDL.Variant({ 'ok' : IDL.Vec(IDL.Text), 'err' : IDL.Text });
+  const Result_2 = IDL.Variant({ 'ok' : IDL.Text, 'err' : IDL.Text });
+  const PropertyStatus = IDL.Variant({
+    'Listed' : IDL.Null,
+    'InTransaction' : IDL.Null,
+    'Cancelled' : IDL.Null,
+    'Completed' : IDL.Null,
+  });
+  const Time = IDL.Int;
+  const Property = IDL.Record({
+    'id' : IDL.Nat,
+    'anonymousPropertyId' : IDL.Text,
+    'status' : PropertyStatus,
+    'propertyType' : IDL.Text,
+    'owner' : IDL.Principal,
+    'createdAt' : Time,
+    'size' : IDL.Nat,
+    'documentsComplete' : IDL.Bool,
+    'description' : IDL.Text,
+    'isVerified' : IDL.Bool,
+    'linkedProperties' : IDL.Vec(IDL.Text),
+    'address' : IDL.Text,
+    'chainPosition' : IDL.Opt(IDL.Nat),
+    'financingComplete' : IDL.Bool,
+    'price' : IDL.Nat,
+    'searchesComplete' : IDL.Bool,
+    'transactionId' : IDL.Opt(IDL.Text),
+  });
+  const ChainPropertyView = IDL.Record({
+    'status' : PropertyStatus,
+    'progressPercentage' : IDL.Nat,
+    'role' : IDL.Text,
+    'documentsComplete' : IDL.Bool,
+    'financingComplete' : IDL.Bool,
+    'searchesComplete' : IDL.Bool,
+    'anonymousId' : IDL.Text,
+  });
+  const Result_1 = IDL.Variant({ 'ok' : ChainPropertyView, 'err' : IDL.Text });
+  const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : IDL.Text });
+  return IDL.Service({
+    'buildPropertyChain' : IDL.Func([IDL.Text], [Result_3], []),
+    'canViewFullPropertyDetails' : IDL.Func(
+        [IDL.Text, IDL.Principal],
+        [IDL.Bool],
+        ['query'],
+      ),
+    'generateAnonymousPropertyId' : IDL.Func([IDL.Text], [Result_2], []),
+    'getAllProperties' : IDL.Func([], [IDL.Vec(Property)], ['query']),
+    'getCycles' : IDL.Func([], [IDL.Nat], ['query']),
+    'getProperty' : IDL.Func([IDL.Nat], [IDL.Opt(Property)], ['query']),
+    'getPropertyForChainView' : IDL.Func(
+        [IDL.Text, IDL.Principal],
+        [Result_1],
+        ['query'],
+      ),
+    'registerProperty' : IDL.Func(
+        [IDL.Text, IDL.Nat, IDL.Nat, IDL.Text, IDL.Text],
+        [IDL.Nat],
+        [],
+      ),
+    'transferOwnership' : IDL.Func([IDL.Nat, IDL.Principal], [IDL.Bool], []),
+    'updatePropertyProgress' : IDL.Func(
+        [IDL.Nat, IDL.Bool, IDL.Bool, IDL.Bool],
+        [Result],
+        [],
+      ),
+    'updatePropertyStatus' : IDL.Func([IDL.Nat, PropertyStatus], [Result], []),
+    'updatePropertyTransaction' : IDL.Func(
+        [IDL.Nat, IDL.Opt(IDL.Text), IDL.Opt(IDL.Nat), IDL.Vec(IDL.Text)],
+        [Result],
+        [],
+      ),
+    'verifyProperty' : IDL.Func([IDL.Nat], [IDL.Bool], []),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/src/client.ts

@@ -3,11 +3,19 @@ import { idlFactory as transactionManagerIdl } from "./canisters/transaction_man
 import { idlFactory as documentStorageIdl } from "./canisters/document_storage/index.js";
 import { idlFactory as userManagementIdl } from "./canisters/user_management/index.js";
 import { idlFactory as ledgerManagerIdl } from "./canisters/ledger_manager/index.js";
+import { idlFactory as propertyRegistryIdl } from "./canisters/property_registry/index.js";
+import { idlFactory as documentVerificationIdl } from "./canisters/document_verification/index.js";
+import { idlFactory as emailServiceIdl } from "./canisters/email_service/index.js";
+import { idlFactory as landRegistryIntegrationIdl } from "./canisters/land_registry_integration/index.js";
 import type {
   TransactionManagerService,
   DocumentStorageService,
   UserManagementService,
   LedgerManagerService,
+  PropertyRegistryService,
+  DocumentVerificationService,
+  EmailServiceService,
+  LandRegistryIntegrationService,
 } from "./types.js";
 import {
   MAINNET_CANISTER_IDS,
@@ -30,6 +38,10 @@ export class PropXchainClient implements IPropXchainClient {
   readonly documentStorage: DocumentStorageService;
   readonly userManagement: UserManagementService;
   readonly ledgerManager: LedgerManagerService;
+  readonly propertyRegistry: PropertyRegistryService;
+  readonly documentVerification: DocumentVerificationService;
+  readonly emailService: EmailServiceService;
+  readonly landRegistryIntegration: LandRegistryIntegrationService;
   readonly auditTrail: AuditTrailStub;
   readonly agentHarness: AgentHarnessStub;
 
@@ -71,6 +83,23 @@ export class PropXchainClient implements IPropXchainClient {
       ledgerManagerIdl,
       { agent, canisterId: canisterIds.ledgerManager },
     );
+    this.propertyRegistry = Actor.createActor<PropertyRegistryService>(
+      propertyRegistryIdl,
+      { agent, canisterId: canisterIds.propertyRegistry },
+    );
+    this.documentVerification = Actor.createActor<DocumentVerificationService>(
+      documentVerificationIdl,
+      { agent, canisterId: canisterIds.documentVerification },
+    );
+    this.emailService = Actor.createActor<EmailServiceService>(
+      emailServiceIdl,
+      { agent, canisterId: canisterIds.emailService },
+    );
+    this.landRegistryIntegration =
+      Actor.createActor<LandRegistryIntegrationService>(
+        landRegistryIntegrationIdl,
+        { agent, canisterId: canisterIds.landRegistryIntegration },
+      );
     this.auditTrail = createAuditTrailStub();
     this.agentHarness = createAgentHarnessStub();
   }

package/src/index.ts

@@ -27,4 +27,22 @@ export {
   type DocumentStorageService,
   type UserManagementService,
   type LedgerManagerService,
+  type PropertyRegistryService,
+  type DocumentVerificationService,
+  type EmailServiceService,
+  type LandRegistryIntegrationService,
 } from "./types.js";
+export {
+  Principal,
+  Ed25519KeyIdentity,
+  AuthClient,
+  Actor,
+  HttpAgent,
+  type Identity,
+  type ActorSubclass,
+  type ActorConfig,
+  type ActorMethod,
+  type AuthClientCreateOptions,
+  type AuthClientLoginOptions,
+  type IdbStorage,
+} from "./auth.js";

package/src/mock.ts

@@ -5,6 +5,10 @@ import type {
   DocumentStorageService,
   UserManagementService,
   LedgerManagerService,
+  PropertyRegistryService,
+  DocumentVerificationService,
+  EmailServiceService,
+  LandRegistryIntegrationService,
 } from "./types.js";
 import {
   createAuditTrailStub,
@@ -87,11 +91,53 @@ export function createMockLedgerManager(): LedgerManagerService {
   });
 }
 
+export function createMockPropertyRegistry(): PropertyRegistryService {
+  return mockService<PropertyRegistryService>({
+    getAllProperties: async () => [],
+    getProperty: async () => [],
+    verifyProperty: async () => false,
+    transferOwnership: async () => false,
+  });
+}
+
+export function createMockDocumentVerification(): DocumentVerificationService {
+  return mockService<DocumentVerificationService>({
+    getPropertyDocuments: async () => [],
+    getUnverifiedDocuments: async () => [],
+    getDocumentVerifications: async () => [],
+    getStats: async () => ({
+      totalDocuments: 0n,
+      verifiedDocuments: 0n,
+      unverifiedDocuments: 0n,
+    }),
+    getAuditLogs: async () => [],
+  });
+}
+
+export function createMockEmailService(): EmailServiceService {
+  return mockService<EmailServiceService>({
+    getAllNotifications: async () => [],
+    getUnprocessedCount: async () => 0n,
+    getUnprocessedNotifications: async () => [],
+  });
+}
+
+export function createMockLandRegistryIntegration(): LandRegistryIntegrationService {
+  return mockService<LandRegistryIntegrationService>({
+    get_all_transactions: async () => [],
+    get_all_pending_land_registry_submissions: async () => [],
+  });
+}
+
 export class MockPropXchainClient implements IPropXchainClient {
   readonly transactionManager: TransactionManagerService;
   readonly documentStorage: DocumentStorageService;
   readonly userManagement: UserManagementService;
   readonly ledgerManager: LedgerManagerService;
+  readonly propertyRegistry: PropertyRegistryService;
+  readonly documentVerification: DocumentVerificationService;
+  readonly emailService: EmailServiceService;
+  readonly landRegistryIntegration: LandRegistryIntegrationService;
   readonly auditTrail: AuditTrailStub;
   readonly agentHarness: AgentHarnessStub;
 
@@ -100,6 +146,10 @@ export class MockPropXchainClient implements IPropXchainClient {
     this.documentStorage = createMockDocumentStorage();
     this.userManagement = createMockUserManagement();
     this.ledgerManager = createMockLedgerManager();
+    this.propertyRegistry = createMockPropertyRegistry();
+    this.documentVerification = createMockDocumentVerification();
+    this.emailService = createMockEmailService();
+    this.landRegistryIntegration = createMockLandRegistryIntegration();
     this.auditTrail = createAuditTrailStub();
     this.agentHarness = createAgentHarnessStub();
   }

package/src/types.ts

@@ -3,6 +3,10 @@ import type { TransactionManagerService } from "./canisters/transaction_manager/
 import type { DocumentStorageService } from "./canisters/document_storage/index.js";
 import type { UserManagementService } from "./canisters/user_management/index.js";
 import type { LedgerManagerService } from "./canisters/ledger_manager/index.js";
+import type { PropertyRegistryService } from "./canisters/property_registry/index.js";
+import type { DocumentVerificationService } from "./canisters/document_verification/index.js";
+import type { EmailServiceService } from "./canisters/email_service/index.js";
+import type { LandRegistryIntegrationService } from "./canisters/land_registry_integration/index.js";
 import type { AuditTrailStub, AgentHarnessStub } from "./stubs.js";
 
 export interface CanisterIds {
@@ -10,6 +14,10 @@ export interface CanisterIds {
   documentStorage: string;
   userManagement: string;
   ledgerManager: string;
+  propertyRegistry: string;
+  documentVerification: string;
+  emailService: string;
+  landRegistryIntegration: string;
 }
 
 export const MAINNET_CANISTER_IDS: CanisterIds = {
@@ -17,6 +25,10 @@ export const MAINNET_CANISTER_IDS: CanisterIds = {
   documentStorage: "646az-pqaaa-aaaaa-qczja-cai",
   userManagement: "lmizp-piaaa-aaaaa-qcwwq-cai",
   ledgerManager: "hty74-maaaa-aaaaa-qcxza-cai",
+  propertyRegistry: "l6oow-dyaaa-aaaaa-qcwvq-cai",
+  documentVerification: "xand7-wiaaa-aaaah-arlea-cai",
+  emailService: "5by6v-qyaaa-aaaaa-qc65a-cai",
+  landRegistryIntegration: "o4flv-xaaaa-aaaaa-qdaeq-cai",
 };
 
 export interface PropXchainClientOptions {
@@ -32,6 +44,10 @@ export interface IPropXchainClient {
   readonly documentStorage: DocumentStorageService;
   readonly userManagement: UserManagementService;
   readonly ledgerManager: LedgerManagerService;
+  readonly propertyRegistry: PropertyRegistryService;
+  readonly documentVerification: DocumentVerificationService;
+  readonly emailService: EmailServiceService;
+  readonly landRegistryIntegration: LandRegistryIntegrationService;
   readonly auditTrail: AuditTrailStub;
   readonly agentHarness: AgentHarnessStub;
 }
@@ -41,4 +57,8 @@ export type {
   DocumentStorageService,
   UserManagementService,
   LedgerManagerService,
+  PropertyRegistryService,
+  DocumentVerificationService,
+  EmailServiceService,
+  LandRegistryIntegrationService,
 };