@propxchain/core-client 0.1.0-canary.3

package/src/canisters/document_storage/document_storage.did

@@ -0,0 +1,89 @@
+type Time = int;
+type Result_3 = 
+ variant {
+   err: text;
+   ok:
+    record {
+      contentType: text;
+      docType: text;
+      fileHash: text;
+      fileName: text;
+      fileSize: nat;
+      id: nat;
+      totalChunks: nat;
+      transactionId: opt text;
+      uploadedAt: int;
+      uploadedBy: principal;
+    };
+ };
+type Result_2 = 
+ variant {
+   err: text;
+   ok: nat;
+ };
+type Result_1 = 
+ variant {
+   err: text;
+   ok: text;
+ };
+type Result = 
+ variant {
+   err: text;
+   ok: bool;
+ };
+type DocumentProof = 
+ record {
+   contentType: text;
+   docType: text;
+   fileHash: text;
+   fileName: text;
+   fileSize: nat;
+   id: nat;
+   storageLocation: text;
+   transactionId: opt text;
+   uploadedAt: Time;
+   uploadedBy: principal;
+   verified: bool;
+ };
+type AuditLog = 
+ record {
+   action: text;
+   actorPrincipal: principal;
+   documentId: nat;
+   id: nat;
+   metadata: text;
+   success: bool;
+   timestamp: Time;
+ };
+service : {
+  deleteDocument: (documentId: nat, csrfToken: text) -> (Result_1);
+  generateCSRFToken: () -> (text);
+  getAuditLogs: (documentId: nat) -> (vec AuditLog) query;
+  getCSRFToken: () -> (opt text) query;
+  getCycles: () -> (nat) query;
+  getDocumentMetadata: (documentId: nat) -> (Result_3) query;
+  getDocumentProof: (documentId: nat) -> (opt DocumentProof) query;
+  getMyAuditLogs: ("principal": principal) -> (vec AuditLog) query;
+  getRecentAuditLogs: (limit: nat) -> (vec AuditLog) query;
+  getStorageStats: () ->
+   (record {
+      averageFileSizeBytes: nat;
+      totalDocuments: nat;
+      totalSizeBytes: nat;
+      verifiedDocuments: nat;
+    }) query;
+  getTransactionDocuments: (transactionId: text) -> (vec DocumentProof) query;
+  getTransactionManagerCanister: () -> (opt principal) query;
+  getUserManagementCanister: () -> (opt principal) query;
+  markDocumentDeleted: (documentId: nat, csrfToken: text) -> (Result_1);
+  registerDocumentProof: (fileName: text, fileHash: text, fileSize: nat,
+   contentType: text, storageLocation: text, transactionId: opt text,
+   docType: text, csrfToken: text) -> (Result_2);
+  setTransactionManagerCanister: (canisterId: principal, csrfToken: text) ->
+   (Result_1);
+  setUserManagementCanister: (canisterId: principal, csrfToken: text) ->
+   (Result_1);
+  validateCSRFToken: (token: text) -> (bool);
+  verifyDocumentHash: (documentId: nat, providedHash: text, csrfToken:
+   text) -> (Result);
+}

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

@@ -0,0 +1,82 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
+
+export interface AuditLog {
+  'id' : bigint,
+  'action' : string,
+  'metadata' : string,
+  'timestamp' : Time,
+  'success' : boolean,
+  'documentId' : bigint,
+  'actorPrincipal' : Principal,
+}
+export interface DocumentProof {
+  'id' : bigint,
+  'verified' : boolean,
+  'contentType' : string,
+  'fileHash' : string,
+  'fileName' : string,
+  'fileSize' : bigint,
+  'storageLocation' : string,
+  'docType' : string,
+  'uploadedAt' : Time,
+  'uploadedBy' : Principal,
+  'transactionId' : [] | [string],
+}
+export type Result = { 'ok' : boolean } |
+  { 'err' : string };
+export type Result_1 = { 'ok' : string } |
+  { 'err' : string };
+export type Result_2 = { 'ok' : bigint } |
+  { 'err' : string };
+export type Result_3 = {
+    'ok' : {
+      'id' : bigint,
+      'contentType' : string,
+      'fileHash' : string,
+      'fileName' : string,
+      'fileSize' : bigint,
+      'totalChunks' : bigint,
+      'docType' : string,
+      'uploadedAt' : bigint,
+      'uploadedBy' : Principal,
+      'transactionId' : [] | [string],
+    }
+  } |
+  { 'err' : string };
+export type Time = bigint;
+export interface _SERVICE {
+  'deleteDocument' : ActorMethod<[bigint, string], Result_1>,
+  'generateCSRFToken' : ActorMethod<[], string>,
+  'getAuditLogs' : ActorMethod<[bigint], Array<AuditLog>>,
+  'getCSRFToken' : ActorMethod<[], [] | [string]>,
+  'getCycles' : ActorMethod<[], bigint>,
+  'getDocumentMetadata' : ActorMethod<[bigint], Result_3>,
+  'getDocumentProof' : ActorMethod<[bigint], [] | [DocumentProof]>,
+  'getMyAuditLogs' : ActorMethod<[Principal], Array<AuditLog>>,
+  'getRecentAuditLogs' : ActorMethod<[bigint], Array<AuditLog>>,
+  'getStorageStats' : ActorMethod<
+    [],
+    {
+      'averageFileSizeBytes' : bigint,
+      'totalSizeBytes' : bigint,
+      'verifiedDocuments' : bigint,
+      'totalDocuments' : bigint,
+    }
+  >,
+  'getTransactionDocuments' : ActorMethod<[string], Array<DocumentProof>>,
+  'getTransactionManagerCanister' : ActorMethod<[], [] | [Principal]>,
+  'getUserManagementCanister' : ActorMethod<[], [] | [Principal]>,
+  'markDocumentDeleted' : ActorMethod<[bigint, string], Result_1>,
+  'registerDocumentProof' : ActorMethod<
+    [string, string, bigint, string, string, [] | [string], string, string],
+    Result_2
+  >,
+  'setTransactionManagerCanister' : ActorMethod<[Principal, string], Result_1>,
+  'setUserManagementCanister' : ActorMethod<[Principal, string], Result_1>,
+  'validateCSRFToken' : ActorMethod<[string], boolean>,
+  'verifyDocumentHash' : ActorMethod<[bigint, string, string], Result>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

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

@@ -0,0 +1,121 @@
+export const idlFactory = ({ IDL }) => {
+  const Result_1 = IDL.Variant({ 'ok' : IDL.Text, 'err' : IDL.Text });
+  const Time = IDL.Int;
+  const AuditLog = IDL.Record({
+    'id' : IDL.Nat,
+    'action' : IDL.Text,
+    'metadata' : IDL.Text,
+    'timestamp' : Time,
+    'success' : IDL.Bool,
+    'documentId' : IDL.Nat,
+    'actorPrincipal' : IDL.Principal,
+  });
+  const Result_3 = IDL.Variant({
+    'ok' : IDL.Record({
+      'id' : IDL.Nat,
+      'contentType' : IDL.Text,
+      'fileHash' : IDL.Text,
+      'fileName' : IDL.Text,
+      'fileSize' : IDL.Nat,
+      'totalChunks' : IDL.Nat,
+      'docType' : IDL.Text,
+      'uploadedAt' : IDL.Int,
+      'uploadedBy' : IDL.Principal,
+      'transactionId' : IDL.Opt(IDL.Text),
+    }),
+    '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_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], []),
+    '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']),
+    'getDocumentProof' : IDL.Func(
+        [IDL.Nat],
+        [IDL.Opt(DocumentProof)],
+        ['query'],
+      ),
+    'getMyAuditLogs' : IDL.Func(
+        [IDL.Principal],
+        [IDL.Vec(AuditLog)],
+        ['query'],
+      ),
+    'getRecentAuditLogs' : IDL.Func([IDL.Nat], [IDL.Vec(AuditLog)], ['query']),
+    'getStorageStats' : IDL.Func(
+        [],
+        [
+          IDL.Record({
+            'averageFileSizeBytes' : IDL.Nat,
+            'totalSizeBytes' : IDL.Nat,
+            'verifiedDocuments' : IDL.Nat,
+            'totalDocuments' : IDL.Nat,
+          }),
+        ],
+        ['query'],
+      ),
+    'getTransactionDocuments' : IDL.Func(
+        [IDL.Text],
+        [IDL.Vec(DocumentProof)],
+        ['query'],
+      ),
+    'getTransactionManagerCanister' : IDL.Func(
+        [],
+        [IDL.Opt(IDL.Principal)],
+        ['query'],
+      ),
+    'getUserManagementCanister' : IDL.Func(
+        [],
+        [IDL.Opt(IDL.Principal)],
+        ['query'],
+      ),
+    'markDocumentDeleted' : IDL.Func([IDL.Nat, IDL.Text], [Result_1], []),
+    'registerDocumentProof' : IDL.Func(
+        [
+          IDL.Text,
+          IDL.Text,
+          IDL.Nat,
+          IDL.Text,
+          IDL.Text,
+          IDL.Opt(IDL.Text),
+          IDL.Text,
+          IDL.Text,
+        ],
+        [Result_2],
+        [],
+      ),
+    'setTransactionManagerCanister' : IDL.Func(
+        [IDL.Principal, IDL.Text],
+        [Result_1],
+        [],
+      ),
+    'setUserManagementCanister' : IDL.Func(
+        [IDL.Principal, IDL.Text],
+        [Result_1],
+        [],
+      ),
+    'validateCSRFToken' : IDL.Func([IDL.Text], [IDL.Bool], []),
+    'verifyDocumentHash' : IDL.Func(
+        [IDL.Nat, IDL.Text, IDL.Text],
+        [Result],
+        [],
+      ),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/src/canisters/document_storage/index.ts

@@ -0,0 +1,5 @@
+export { idlFactory } from "./document_storage.did.js";
+export type {
+  _SERVICE as DocumentStorageService,
+} from "./document_storage.did.js";
+export type * from "./document_storage.did.js";

package/src/canisters/ledger_manager/index.ts

@@ -0,0 +1,5 @@
+export { idlFactory } from "./ledger_manager.did.js";
+export type {
+  _SERVICE as LedgerManagerService,
+} from "./ledger_manager.did.js";
+export type * from "./ledger_manager.did.js";

package/src/canisters/ledger_manager/ledger_manager.did

@@ -0,0 +1,154 @@
+type VerificationStatus = 
+ variant {
+   failed;
+   pending;
+   verified;
+ };
+type UserLedgerEntry = 
+ record {
+   accountID: text;
+   completedDate: opt Time;
+   costsSaved: nat;
+   counterparties: vec Counterparty;
+   documentStatus: DocumentVerification;
+   entryID: text;
+   initiatedDate: Time;
+   propertyAddress: text;
+   propertyValue: nat;
+   roleInTransaction: TransactionRole;
+   status: TransactionStatus;
+   transactionID: text;
+ };
+type UserAccount = 
+ record {
+   accountID: text;
+   accountType: AccountType;
+   companyName: opt text;
+   email: text;
+   isActive: bool;
+   name: text;
+   registrationDate: Time;
+   taxID: opt text;
+ };
+type TransactionStatus = 
+ variant {
+   active;
+   completed;
+   failed;
+   pending;
+ };
+type TransactionRole = 
+ variant {
+   agent;
+   buyer;
+   seller;
+   solicitor;
+ };
+type Time = int;
+type TeamPermissions = 
+ record {
+   canInitiate: bool;
+   canManageTeam: bool;
+   canSign: bool;
+   canViewAnalytics: bool;
+ };
+type TeamMemberRole = 
+ variant {
+   admin;
+   manager;
+   viewer;
+ };
+type Result = 
+ variant {
+   err: text;
+   ok: text;
+ };
+type DocumentVerification = 
+ record {
+   landRegistryConfirm: VerificationStatus;
+   mortgageApproval: VerificationStatus;
+   propertyDeed: VerificationStatus;
+   surveyReport: VerificationStatus;
+ };
+type Counterparty = 
+ record {
+   accountID: text;
+   name: text;
+ };
+type CompanyTeamMember = 
+ record {
+   accountID: text;
+   email: text;
+   joinDate: Time;
+   memberID: text;
+   name: text;
+   permissions: TeamPermissions;
+   role: TeamMemberRole;
+ };
+type CompanyLedger = 
+ record {
+   activeTransactions: nat;
+   avgCompletionTime: nat;
+   companyAccountID: text;
+   completedThisMonth: nat;
+   costSavings: nat;
+   teamMemberCount: nat;
+   totalTransactions: nat;
+ };
+type BlockchainEfficiencyMetrics = 
+ record {
+   avgBlockchainCompletionDays: nat;
+   avgBlockchainCost: nat;
+   avgTraditionalCompletionDays: nat;
+   avgTraditionalCost: nat;
+   costReductionPercent: nat;
+   timeReductionPercent: nat;
+   totalCostSaved: nat;
+   totalTimeSavedDays: nat;
+   transactionsCompleted: nat;
+ };
+type Analytics = 
+ record {
+   avgCompletionTime: nat;
+   completedTransactions: nat;
+   period: text;
+   totalCostSavings: nat;
+   totalTransactions: nat;
+   transactionVolume: nat;
+ };
+type AccountType = 
+ variant {
+   company;
+   individual;
+ };
+service : {
+  addTransactionToLedger: (accountID: text, transactionID: text,
+   roleInTransaction: TransactionRole, propertyAddress: text, propertyValue:
+   nat, counterparties: vec Counterparty) -> (bool);
+  createCompanyTeamMember: (companyID: text, name: text, email: text, role:
+   TeamMemberRole, permissions: TeamPermissions) -> (text);
+  createUserAccount: (name: text, email: text, accountType: AccountType,
+   companyName: opt text, taxID: opt text) -> (text);
+  getBlockchainEfficiencyMetrics: (accountID: text) ->
+   (BlockchainEfficiencyMetrics) query;
+  getCompanyLedger: (companyAccountID: text) -> (CompanyLedger) query;
+  getCompanyTeamMembers: (companyAccountID: text) ->
+   (vec CompanyTeamMember) query;
+  getCycles: () -> (nat) query;
+  getGlobalBlockchainStats: () -> (BlockchainEfficiencyMetrics) query;
+  getLedgerAnalytics: (accountID: text, period: text) -> (Analytics) query;
+  getMyAccount: () -> (opt UserAccount) query;
+  getMyLedger: () -> (vec UserLedgerEntry) query;
+  getUserAccount: (accountID: text) -> (opt UserAccount) query;
+  getUserLedger: (accountID: text) -> (vec UserLedgerEntry) query;
+  setDocumentVerificationCanister: (canisterId: principal) -> ();
+  setPropertyRegistryCanister: (canisterId: principal) -> ();
+  setTransactionManagerCanister: (canisterId: principal) -> ();
+  setUserManagementCanister: (canisterId: principal) -> ();
+  syncTransactionToLedger: (transactionId: nat, userPrincipal: principal) ->
+   (Result);
+  updateTeamMemberPermissions: (companyID: text, memberID: text, permissions:
+   TeamPermissions) -> (bool);
+  updateTransactionStatus: (transactionID: text, accountID: text, newStatus:
+   TransactionStatus) -> (bool);
+}

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

@@ -0,0 +1,139 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
+
+export type AccountType = { 'company' : null } |
+  { 'individual' : null };
+export interface Analytics {
+  'transactionVolume' : bigint,
+  'avgCompletionTime' : bigint,
+  'period' : string,
+  'totalCostSavings' : bigint,
+  'completedTransactions' : bigint,
+  'totalTransactions' : bigint,
+}
+export interface BlockchainEfficiencyMetrics {
+  'avgBlockchainCompletionDays' : bigint,
+  'totalCostSaved' : bigint,
+  'avgTraditionalCompletionDays' : bigint,
+  'timeReductionPercent' : bigint,
+  'avgTraditionalCost' : bigint,
+  'avgBlockchainCost' : bigint,
+  'transactionsCompleted' : bigint,
+  'costReductionPercent' : bigint,
+  'totalTimeSavedDays' : bigint,
+}
+export interface CompanyLedger {
+  'companyAccountID' : string,
+  'avgCompletionTime' : bigint,
+  'costSavings' : bigint,
+  'completedThisMonth' : bigint,
+  'activeTransactions' : bigint,
+  'teamMemberCount' : bigint,
+  'totalTransactions' : bigint,
+}
+export interface CompanyTeamMember {
+  'memberID' : string,
+  'permissions' : TeamPermissions,
+  'accountID' : string,
+  'joinDate' : Time,
+  'name' : string,
+  'role' : TeamMemberRole,
+  'email' : string,
+}
+export interface Counterparty { 'accountID' : string, 'name' : string }
+export interface DocumentVerification {
+  'mortgageApproval' : VerificationStatus,
+  'propertyDeed' : VerificationStatus,
+  'landRegistryConfirm' : VerificationStatus,
+  'surveyReport' : VerificationStatus,
+}
+export type Result = { 'ok' : string } |
+  { 'err' : string };
+export type TeamMemberRole = { 'manager' : null } |
+  { 'admin' : null } |
+  { 'viewer' : null };
+export interface TeamPermissions {
+  'canSign' : boolean,
+  'canInitiate' : boolean,
+  'canViewAnalytics' : boolean,
+  'canManageTeam' : boolean,
+}
+export type Time = bigint;
+export type TransactionRole = { 'agent' : null } |
+  { 'solicitor' : null } |
+  { 'seller' : null } |
+  { 'buyer' : null };
+export type TransactionStatus = { 'active' : null } |
+  { 'pending' : null } |
+  { 'completed' : null } |
+  { 'failed' : null };
+export interface UserAccount {
+  'taxID' : [] | [string],
+  'accountID' : string,
+  'name' : string,
+  'isActive' : boolean,
+  'email' : string,
+  'accountType' : AccountType,
+  'companyName' : [] | [string],
+  'registrationDate' : Time,
+}
+export interface UserLedgerEntry {
+  'completedDate' : [] | [Time],
+  'initiatedDate' : Time,
+  'status' : TransactionStatus,
+  'accountID' : string,
+  'documentStatus' : DocumentVerification,
+  'costsSaved' : bigint,
+  'propertyAddress' : string,
+  'entryID' : string,
+  'propertyValue' : bigint,
+  'roleInTransaction' : TransactionRole,
+  'counterparties' : Array<Counterparty>,
+  'transactionID' : string,
+}
+export type VerificationStatus = { 'verified' : null } |
+  { 'pending' : null } |
+  { 'failed' : null };
+export interface _SERVICE {
+  'addTransactionToLedger' : ActorMethod<
+    [string, string, TransactionRole, string, bigint, Array<Counterparty>],
+    boolean
+  >,
+  'createCompanyTeamMember' : ActorMethod<
+    [string, string, string, TeamMemberRole, TeamPermissions],
+    string
+  >,
+  'createUserAccount' : ActorMethod<
+    [string, string, AccountType, [] | [string], [] | [string]],
+    string
+  >,
+  'getBlockchainEfficiencyMetrics' : ActorMethod<
+    [string],
+    BlockchainEfficiencyMetrics
+  >,
+  'getCompanyLedger' : ActorMethod<[string], CompanyLedger>,
+  'getCompanyTeamMembers' : ActorMethod<[string], Array<CompanyTeamMember>>,
+  'getCycles' : ActorMethod<[], bigint>,
+  'getGlobalBlockchainStats' : ActorMethod<[], BlockchainEfficiencyMetrics>,
+  'getLedgerAnalytics' : ActorMethod<[string, string], Analytics>,
+  'getMyAccount' : ActorMethod<[], [] | [UserAccount]>,
+  'getMyLedger' : ActorMethod<[], Array<UserLedgerEntry>>,
+  'getUserAccount' : ActorMethod<[string], [] | [UserAccount]>,
+  'getUserLedger' : ActorMethod<[string], Array<UserLedgerEntry>>,
+  'setDocumentVerificationCanister' : ActorMethod<[Principal], undefined>,
+  'setPropertyRegistryCanister' : ActorMethod<[Principal], undefined>,
+  'setTransactionManagerCanister' : ActorMethod<[Principal], undefined>,
+  'setUserManagementCanister' : ActorMethod<[Principal], undefined>,
+  'syncTransactionToLedger' : ActorMethod<[bigint, Principal], Result>,
+  'updateTeamMemberPermissions' : ActorMethod<
+    [string, string, TeamPermissions],
+    boolean
+  >,
+  'updateTransactionStatus' : ActorMethod<
+    [string, string, TransactionStatus],
+    boolean
+  >,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];