@propxchain/core-client 0.2.1-canary.20 → 0.2.1-canary.22

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

@@ -1,6 +1,6 @@
-import type { Principal } from '@icp-sdk/core/principal';
-import type { ActorMethod } from '@icp-sdk/core/agent';
-import type { IDL } from '@icp-sdk/core/candid';
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
 
 export interface ChainPropertyView {
   'status' : PropertyStatus,

package/src/canisters/transaction_manager/transaction_manager.did

@@ -576,6 +576,32 @@ service : {
   joinAsBotByInviteCode: (inviteCode: text, botName: text) -> (Result_6);
   joinTransactionByInviteCode: (inviteCode: text) -> (Result_6);
   joinTransactionByInviteCodeAsBuyer: (inviteCode: text) -> (Result_6);
+  /// Caller-initiated removal from a transaction they joined but didn't
+  /// create. Counterpart to `removeParty` (which is seller/admin-driven and
+  /// gated against primary parties) — this is the "I want out" path for a
+  /// joined buyer or any other access-list member.
+  /// 
+  /// Gates:
+  ///   - Anonymous callers rejected outright.
+  ///   - Seller / createdBy cannot leave their own transaction (they
+  ///     dispose via deleteTransaction).
+  ///   - Caller must currently have access to the transaction.
+  ///   - Locked after contract exchange (same posture as assignBuyer):
+  ///     once the deal is signed nobody walks away by toggling a button.
+  /// 
+  /// Effects:
+  ///   - Caller is removed from `accessList`.
+  ///   - If the caller is the assigned buyer (`txn.buyer == msg.caller`),
+  ///     the buyer slot is reset to the seller placeholder, matching the
+  ///     sentinel state that `assignBuyer` checks for. The transaction
+  ///     re-enters the "Awaiting buyer" state and the invite code is
+  ///     reusable by a new joiner.
+  ///   - Audit event `buyer_left` (or `party_left` for non-buyer leavers)
+  ///     is logged via the existing ledger pattern.
+  /// 
+  /// Concurrency: uses the same acquireTxLock/finally releaseTxLock
+  /// posture as assignBuyer so a leave can't race against an in-flight
+  /// stage write.
   leaveTransaction: (transactionId: text) -> (Result);
   linkTransactionToChain: (myTransactionId: text, buyingTransactionId:
    text) -> (Result_1);
@@ -590,6 +616,7 @@ service : {
   ///   2. Stale-pin txs where the org's pinned principal changed after the
   ///      tx was created (e.g. admin password reset → new ICP key, or org
   ///      ownership transferred to a different admin).
+  /// 
   /// Idempotent over the target: re-running with the same developerPrincipal
   /// returns an error (already at target), so admin-driven backfill scripts
   /// don't silently re-touch state. Always rejects:

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

@@ -483,6 +483,34 @@ export interface _SERVICE {
   'joinAsBotByInviteCode' : ActorMethod<[string, string], Result_6>,
   'joinTransactionByInviteCode' : ActorMethod<[string], Result_6>,
   'joinTransactionByInviteCodeAsBuyer' : ActorMethod<[string], Result_6>,
+  /**
+   * / Caller-initiated removal from a transaction they joined but didn't
+   * / create. Counterpart to `removeParty` (which is seller/admin-driven and
+   * / gated against primary parties) — this is the "I want out" path for a
+   * / joined buyer or any other access-list member.
+   * /
+   * / Gates:
+   * /   - Anonymous callers rejected outright.
+   * /   - Seller / createdBy cannot leave their own transaction (they
+   * /     dispose via deleteTransaction).
+   * /   - Caller must currently have access to the transaction.
+   * /   - Locked after contract exchange (same posture as assignBuyer):
+   * /     once the deal is signed nobody walks away by toggling a button.
+   * /
+   * / Effects:
+   * /   - Caller is removed from `accessList`.
+   * /   - If the caller is the assigned buyer (`txn.buyer == msg.caller`),
+   * /     the buyer slot is reset to the seller placeholder, matching the
+   * /     sentinel state that `assignBuyer` checks for. The transaction
+   * /     re-enters the "Awaiting buyer" state and the invite code is
+   * /     reusable by a new joiner.
+   * /   - Audit event `buyer_left` (or `party_left` for non-buyer leavers)
+   * /     is logged via the existing ledger pattern.
+   * /
+   * / Concurrency: uses the same acquireTxLock/finally releaseTxLock
+   * / posture as assignBuyer so a leave can't race against an in-flight
+   * / stage write.
+   */
   'leaveTransaction' : ActorMethod<[string], Result>,
   'linkTransactionToChain' : ActorMethod<[string, string], Result_1>,
   'markAllNotificationsRead' : ActorMethod<[], bigint>,
@@ -497,6 +525,7 @@ export interface _SERVICE {
    * /   2. Stale-pin txs where the org's pinned principal changed after the
    * /      tx was created (e.g. admin password reset → new ICP key, or org
    * /      ownership transferred to a different admin).
+   * /
    * / Idempotent over the target: re-running with the same developerPrincipal
    * / returns an error (already at target), so admin-driven backfill scripts
    * / don't silently re-touch state. Always rejects:

package/src/canisters/user_management/user_management.did

@@ -29,12 +29,16 @@ type UserRole =
  };
 type UserProfile = 
  record {
+   businessGatewayEnabled: bool;
+   businessGatewayUsername: opt text;
    clientPrincipals: vec principal;
+   conveyancerReference: opt text;
    createdAt: Time;
    email: text;
    emailVerificationSentAt: opt Time;
    emailVerificationToken: opt text;
    emailVerified: bool;
+   firmSRANumber: opt text;
    isPlatformOnlySolicitor: bool;
    isVerified: bool;
    lawFirmAddress: opt text;
@@ -45,6 +49,7 @@ type UserProfile =
    "principal": principal;
    role: opt UserRole;
    solicitorLicenseNumber: opt text;
+   sraNumber: opt text;
    userType: UserType;
  };
 type TransactionProgress = 
@@ -71,6 +76,51 @@ type TransactionMember =
    uploadedDocuments: vec text;
  };
 type Time = int;
+type SolicitorSubmissionDetails = 
+ record {
+   businessGatewayEnabled: bool;
+   conveyancerReference: opt text;
+   email: text;
+   firmAddress: text;
+   firmName: text;
+   firmSRANumber: opt text;
+   fullName: text;
+   principalId: principal;
+   sraNumber: text;
+ };
+type Result_5 = 
+ variant {
+   err: text;
+   ok: SolicitorSubmissionDetails;
+ };
+type Result_4 = 
+ variant {
+   err: text;
+   ok;
+ };
+type Result_3 = 
+ variant {
+   err: text;
+   ok: nat;
+ };
+type Result_2 = 
+ variant {
+   err: text;
+   ok: BotAgent;
+ };
+type Result_1 = 
+ variant {
+   err: text;
+   ok: text;
+ };
+type Result = 
+ variant {
+   err: text;
+   ok: record {
+         ownerPrincipal: principal;
+         role: BotRole;
+       };
+ };
 type Permission = 
  variant {
    AdminManageUsers;
@@ -85,13 +135,35 @@ type Permission =
    ViewSharedTransaction: text;
    ViewTransactionProgress: text;
  };
-type ActorType =
+type BotRole = 
  variant {
-   agent;
-   systemActor;
-   user;
+   BotFirm;
+   BotInternal;
+   BotPersonal;
  };
-type AuditLog =
+type BotAgent = 
+ record {
+   botPrincipal: principal;
+   callCount: nat;
+   createdAt: Time;
+   description: text;
+   isActive: bool;
+   lastActive: Time;
+   name: text;
+   ownerPrincipal: principal;
+   role: BotRole;
+ };
+type BotActionLog = 
+ record {
+   action: text;
+   botPrincipal: principal;
+   id: nat;
+   metadata: text;
+   success: bool;
+   timestamp: Time;
+   transactionId: opt text;
+ };
+type AuditLog = 
  record {
    action: text;
    actorPrincipal: principal;
@@ -104,12 +176,12 @@ type AuditLog =
    timestamp: Time;
    transactionId: opt text;
  };
-type AdminRole =
+type AdminRole = 
  variant {
    regular;
-   "super";
+   super;
  };
-type AdminRecord =
+type AdminRecord = 
  record {
    grantedAt: Time;
    grantedBy: principal;
@@ -117,7 +189,17 @@ type AdminRecord =
    "principal": principal;
    role: AdminRole;
  };
-type AdminMutationError =
+type AdminMutationResult_1 = 
+ variant {
+   err: AdminMutationError;
+   ok;
+ };
+type AdminMutationResult = 
+ variant {
+   err: AdminMutationError;
+   ok: AdminRecord;
+ };
+type AdminMutationError = 
  variant {
    anonymousCaller;
    cannotDemoteController;
@@ -126,68 +208,88 @@ type AdminMutationError =
    notSuperAdmin;
    targetIsAnonymous;
  };
+type ActorType = 
+ variant {
+   agent;
+   systemActor;
+   user;
+ };
 service : {
   addTransactionMember: (transactionId: text, memberPrincipal: principal,
    role: UserType, canViewProgress: bool, canInviteOthers: bool, csrfToken:
    text) -> (bool);
+  adminLinkPrincipals: (primary: principal, alias: principal) -> (Result_1);
   amIAdmin: () -> (bool) query;
   bootstrapAdmin: (name: text, email: text) -> (bool);
   canUserAccessTransaction: (user: principal, txId: text) -> (bool) query;
   checkPermissionWithAudit: (permission: Permission) -> (bool);
+  claimLinkCode: (code: text) -> (Result_1);
   createUserForPrincipal: (targetPrincipal: principal, name: text, email:
    text, mobile: text, userTypeText: text, csrfToken: text) -> (bool);
+  deactivateBot: (botPrincipal: principal) -> (Result_4);
   deleteUserByPrincipal: (targetPrincipal: principal, csrfToken: text) ->
    (bool);
   demoteAdmin: (target: principal, csrfToken: text) ->
-   (variant {
-      err: AdminMutationError;
-      ok;
-    });
+   (AdminMutationResult_1);
   generateCSRFToken: () -> (text);
+  generateLinkCode: () -> (Result_1);
+  getAllBots: () -> (vec BotAgent) query;
   getAllUsers: () -> (vec UserProfile) query;
   getAuditLogs: (limit: nat) -> (vec AuditLog) query;
+  getBotActionLogs: (botPrincipal: principal, limit: nat) ->
+   (vec BotActionLog) query;
+  getBotAgent: (botPrincipal: principal) -> (opt BotAgent) query;
   getCSRFToken: () -> (opt text) query;
   getCycles: () -> (nat) query;
+  getLinkedPrincipals: ("principal": principal) -> (vec principal) query;
+  getMyBots: () -> (vec BotAgent) query;
+  getMyLinkedPrincipals: () -> (vec principal) query;
   getMyManagingSolicitor: () -> (opt UserProfile) query;
   getMyProfile: () -> (opt UserProfile) query;
   getMyProfileUpdate: () -> (opt UserProfile);
   getMySolicitorClients: () -> (vec UserProfile) query;
+  getSolicitorSubmissionDetails: (solicitorPrincipal: principal) ->
+   (Result_5) query;
   getTransactionMembers: (transactionId: text) ->
    (opt vec TransactionMember) query;
   getTransactionProgress: (transactionId: text) ->
    (opt TransactionProgress) query;
   getUserProfile: ("principal": principal) -> (opt UserProfile) query;
+  getUserProfileByPrincipal: ("principal": principal) ->
+   (opt UserProfile) query;
   hasPermission: (permission: Permission) -> (bool) query;
-  linkSolicitorToClient: (solicitorPrincipal: principal, consentGiven:
+  linkSolicitorToClient: (solicitorPrincipal: principal, consentGiven: 
    bool, csrfToken: text) -> (bool);
   listAdmins: () -> (vec AdminRecord) query;
+  logBotAction: (botPrincipal: principal, action: text, transactionId:
+   opt text, success: bool, metadata: text) -> (Result_4);
   myAdminRole: () -> (opt AdminRole) query;
   promoteAdmin: (target: principal, role: AdminRole, note: opt text,
-   csrfToken: text) ->
-   (variant {
-      err: AdminMutationError;
-      ok: AdminRecord;
-    });
+   csrfToken: text) -> (AdminMutationResult);
+  reactivateBot: (botPrincipal: principal) -> (Result_4);
   recordAuditEntry: (actorType: ActorType, delegatedBy: opt principal,
    action: text, targetPrincipal: opt principal, transactionId: opt text,
-   success: bool, metadata: text) ->
-   (variant {
-      err: text;
-      ok: nat;
-    });
+   success: bool, metadata: text) -> (Result_3);
+  registerBot: (botPrincipal: principal, name: text, description: text, role:
+   BotRole) -> (Result_2);
   registerUser: (name: text, email: text, mobile: text, userType: text) ->
    (bool);
   registerUserV2: (name: text, email: text, mobile: text, userType: UserType,
    solicitorLicenseNumber: opt text, lawFirmName: opt text, lawFirmAddress:
-   opt text, csrfToken: text) -> (bool);
+   opt text, sraNumber: opt text, csrfToken: text) -> (bool);
   resendVerificationEmail: (csrfToken: text) -> (bool);
   revokeSolicitorAccess: (solicitorPrincipal: principal, csrfToken: text) ->
    (bool);
+  unlinkPrincipal: (alias: principal) -> (Result_1);
   updateMemberDocuments: (transactionId: text, uploadedDocumentName: 
    text, csrfToken: text) -> (bool);
+  updateSolicitorLRDetails: (sraNumber: opt text, businessGatewayEnabled:
+   bool, businessGatewayUsername: opt text, firmSRANumber: opt text,
+   conveyancerReference: opt text) -> (Result_1);
   updateTransactionMemberRequiredDocs: (transactionId: text,
    documentsToRemove: vec text, csrfToken: text) -> (bool);
   validateAdmin: ("principal": principal) -> (bool) query;
+  validateBot: (botPrincipal: principal) -> (Result) query;
   validateCSRFToken: (token: text) -> (bool);
   verifyEmail: (token: text, csrfToken: text) -> (bool);
   verifyUser: (userPrincipal: principal, csrfToken: text) -> (bool);

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

@@ -1,37 +1,64 @@
-import type { Principal } from '@icp-sdk/core/principal';
-import type { ActorMethod } from '@icp-sdk/core/agent';
-import type { IDL } from '@icp-sdk/core/candid';
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
 
-export type ActorType = { 'user' : null } |
-  { 'agent' : null } |
-  { 'systemActor' : null };
-export type AdminMutationError = { 'notSuperAdmin' : null } |
+export type ActorType = { 'agent' : null } |
+  { 'systemActor' : null } |
+  { 'user' : null };
+export type AdminMutationError = { 'targetIsAnonymous' : null } |
   { 'cannotDemoteController' : null } |
+  { 'notSuperAdmin' : null } |
   { 'invalidCsrfToken' : null } |
-  { 'cannotDemoteLastSuperAdmin' : null } |
   { 'anonymousCaller' : null } |
-  { 'targetIsAnonymous' : null };
+  { 'cannotDemoteLastSuperAdmin' : null };
+export type AdminMutationResult = { 'ok' : AdminRecord } |
+  { 'err' : AdminMutationError };
+export type AdminMutationResult_1 = { 'ok' : null } |
+  { 'err' : AdminMutationError };
 export interface AdminRecord {
   'principal' : Principal,
-  'note' : [] | [string],
-  'role' : AdminRole,
   'grantedAt' : Time,
   'grantedBy' : Principal,
+  'note' : [] | [string],
+  'role' : AdminRole,
 }
-export type AdminRole = { 'super' : null } |
-  { 'regular' : null };
+export type AdminRole = { 'regular' : null } |
+  { 'super' : null };
 export interface AuditLog {
   'id' : bigint,
   'action' : string,
+  'actorType' : ActorType,
   'metadata' : string,
+  'delegatedBy' : [] | [Principal],
   'targetPrincipal' : [] | [Principal],
   'timestamp' : Time,
   'success' : boolean,
   'actorPrincipal' : Principal,
-  'actorType' : ActorType,
-  'delegatedBy' : [] | [Principal],
   'transactionId' : [] | [string],
 }
+export interface BotActionLog {
+  'id' : bigint,
+  'action' : string,
+  'metadata' : string,
+  'timestamp' : Time,
+  'success' : boolean,
+  'botPrincipal' : Principal,
+  'transactionId' : [] | [string],
+}
+export interface BotAgent {
+  'ownerPrincipal' : Principal,
+  'name' : string,
+  'createdAt' : Time,
+  'role' : BotRole,
+  'description' : string,
+  'isActive' : boolean,
+  'callCount' : bigint,
+  'lastActive' : Time,
+  'botPrincipal' : Principal,
+}
+export type BotRole = { 'BotFirm' : null } |
+  { 'BotInternal' : null } |
+  { 'BotPersonal' : null };
 export type Permission = { 'ViewTransactionProgress' : string } |
   { 'ViewSharedTransaction' : string } |
   { 'ViewDevelopmentUnits' : string } |
@@ -40,6 +67,31 @@ export type Permission = { 'ViewTransactionProgress' : string } |
   { 'AdminViewAllTransactions' : null } |
   { 'AdminManageUsers' : null } |
   { 'UpdateMemberDocuments' : [string, Principal] };
+export type Result = {
+    'ok' : { 'ownerPrincipal' : Principal, 'role' : BotRole }
+  } |
+  { 'err' : string };
+export type Result_1 = { 'ok' : string } |
+  { 'err' : string };
+export type Result_2 = { 'ok' : BotAgent } |
+  { 'err' : string };
+export type Result_3 = { 'ok' : bigint } |
+  { 'err' : string };
+export type Result_4 = { 'ok' : null } |
+  { 'err' : string };
+export type Result_5 = { 'ok' : SolicitorSubmissionDetails } |
+  { 'err' : string };
+export interface SolicitorSubmissionDetails {
+  'firmSRANumber' : [] | [string],
+  'fullName' : string,
+  'firmName' : string,
+  'email' : string,
+  'businessGatewayEnabled' : boolean,
+  'conveyancerReference' : [] | [string],
+  'sraNumber' : string,
+  'principalId' : Principal,
+  'firmAddress' : string,
+}
 export type Time = bigint;
 export interface TransactionMember {
   'uploadedDocuments' : Array<string>,
@@ -67,18 +119,23 @@ export interface UserProfile {
   'userType' : UserType,
   'principal' : Principal,
   'managedBySolicitor' : [] | [Principal],
+  'firmSRANumber' : [] | [string],
   'emailVerified' : boolean,
   'name' : string,
   'createdAt' : Time,
   'role' : [] | [UserRole],
+  'businessGatewayUsername' : [] | [string],
   'email' : string,
   'lawFirmName' : [] | [string],
   'isVerified' : boolean,
   'clientPrincipals' : Array<Principal>,
+  'businessGatewayEnabled' : boolean,
   'emailVerificationSentAt' : [] | [Time],
   'emailVerificationToken' : [] | [string],
+  'conveyancerReference' : [] | [string],
   'mobile' : string,
   'solicitorLicenseNumber' : [] | [string],
+  'sraNumber' : [] | [string],
   'lawFirmAddress' : [] | [string],
 }
 export type UserRole = { 'admin' : null } |
@@ -109,44 +166,56 @@ export interface _SERVICE {
     [string, Principal, UserType, boolean, boolean, string],
     boolean
   >,
+  'adminLinkPrincipals' : ActorMethod<[Principal, Principal], Result_1>,
   'amIAdmin' : ActorMethod<[], boolean>,
   'bootstrapAdmin' : ActorMethod<[string, string], boolean>,
   'canUserAccessTransaction' : ActorMethod<[Principal, string], boolean>,
   'checkPermissionWithAudit' : ActorMethod<[Permission], boolean>,
+  'claimLinkCode' : ActorMethod<[string], Result_1>,
   'createUserForPrincipal' : ActorMethod<
     [Principal, string, string, string, string, string],
     boolean
   >,
+  'deactivateBot' : ActorMethod<[Principal], Result_4>,
   'deleteUserByPrincipal' : ActorMethod<[Principal, string], boolean>,
-  'demoteAdmin' : ActorMethod<
-    [Principal, string],
-    { 'ok' : null } |
-      { 'err' : AdminMutationError }
-  >,
+  'demoteAdmin' : ActorMethod<[Principal, string], AdminMutationResult_1>,
   'generateCSRFToken' : ActorMethod<[], string>,
+  'generateLinkCode' : ActorMethod<[], Result_1>,
+  'getAllBots' : ActorMethod<[], Array<BotAgent>>,
   'getAllUsers' : ActorMethod<[], Array<UserProfile>>,
   'getAuditLogs' : ActorMethod<[bigint], Array<AuditLog>>,
+  'getBotActionLogs' : ActorMethod<[Principal, bigint], Array<BotActionLog>>,
+  'getBotAgent' : ActorMethod<[Principal], [] | [BotAgent]>,
   'getCSRFToken' : ActorMethod<[], [] | [string]>,
   'getCycles' : ActorMethod<[], bigint>,
+  'getLinkedPrincipals' : ActorMethod<[Principal], Array<Principal>>,
+  'getMyBots' : ActorMethod<[], Array<BotAgent>>,
+  'getMyLinkedPrincipals' : ActorMethod<[], Array<Principal>>,
   'getMyManagingSolicitor' : ActorMethod<[], [] | [UserProfile]>,
   'getMyProfile' : ActorMethod<[], [] | [UserProfile]>,
   'getMyProfileUpdate' : ActorMethod<[], [] | [UserProfile]>,
   'getMySolicitorClients' : ActorMethod<[], Array<UserProfile>>,
+  'getSolicitorSubmissionDetails' : ActorMethod<[Principal], Result_5>,
   'getTransactionMembers' : ActorMethod<
     [string],
     [] | [Array<TransactionMember>]
   >,
   'getTransactionProgress' : ActorMethod<[string], [] | [TransactionProgress]>,
   'getUserProfile' : ActorMethod<[Principal], [] | [UserProfile]>,
+  'getUserProfileByPrincipal' : ActorMethod<[Principal], [] | [UserProfile]>,
   'hasPermission' : ActorMethod<[Permission], boolean>,
   'linkSolicitorToClient' : ActorMethod<[Principal, boolean, string], boolean>,
   'listAdmins' : ActorMethod<[], Array<AdminRecord>>,
+  'logBotAction' : ActorMethod<
+    [Principal, string, [] | [string], boolean, string],
+    Result_4
+  >,
   'myAdminRole' : ActorMethod<[], [] | [AdminRole]>,
   'promoteAdmin' : ActorMethod<
     [Principal, AdminRole, [] | [string], string],
-    { 'ok' : AdminRecord } |
-      { 'err' : AdminMutationError }
+    AdminMutationResult
   >,
+  'reactivateBot' : ActorMethod<[Principal], Result_4>,
   'recordAuditEntry' : ActorMethod<
     [
       ActorType,
@@ -157,9 +226,9 @@ export interface _SERVICE {
       boolean,
       string,
     ],
-    { 'ok' : bigint } |
-      { 'err' : string }
+    Result_3
   >,
+  'registerBot' : ActorMethod<[Principal, string, string, BotRole], Result_2>,
   'registerUser' : ActorMethod<[string, string, string, string], boolean>,
   'registerUserV2' : ActorMethod<
     [
@@ -170,18 +239,25 @@ export interface _SERVICE {
       [] | [string],
       [] | [string],
       [] | [string],
+      [] | [string],
       string,
     ],
     boolean
   >,
   'resendVerificationEmail' : ActorMethod<[string], boolean>,
   'revokeSolicitorAccess' : ActorMethod<[Principal, string], boolean>,
+  'unlinkPrincipal' : ActorMethod<[Principal], Result_1>,
   'updateMemberDocuments' : ActorMethod<[string, string, string], boolean>,
+  'updateSolicitorLRDetails' : ActorMethod<
+    [[] | [string], boolean, [] | [string], [] | [string], [] | [string]],
+    Result_1
+  >,
   'updateTransactionMemberRequiredDocs' : ActorMethod<
     [string, Array<string>, string],
     boolean
   >,
   'validateAdmin' : ActorMethod<[Principal], boolean>,
+  'validateBot' : ActorMethod<[Principal], Result>,
   'validateCSRFToken' : ActorMethod<[string], boolean>,
   'verifyEmail' : ActorMethod<[string, string], boolean>,
   'verifyUser' : ActorMethod<[Principal, string], boolean>,