@propxchain/core-client 0.1.0-canary.3

package/src/canisters/user_management/user_management.did

@@ -0,0 +1,147 @@
+type UserType = 
+ variant {
+   admin;
+   assisted_buyer;
+   assisted_seller;
+   buyer;
+   conveyancer_managed;
+   conveyancer_transparent;
+   diy_buyer;
+   diy_seller;
+   estate_agent;
+   mortgage_broker;
+   platform_admin;
+   platform_support;
+   property_developer;
+   seller;
+   solicitor_client_linked;
+   solicitor_managed;
+   solicitor_platform_only;
+   solicitor_transparent;
+ };
+type UserRole = 
+ variant {
+   admin;
+   buyer;
+   guest;
+   seller;
+   solicitor;
+ };
+type UserProfile = 
+ record {
+   clientPrincipals: vec principal;
+   createdAt: Time;
+   email: text;
+   emailVerificationSentAt: opt Time;
+   emailVerificationToken: opt text;
+   emailVerified: bool;
+   isPlatformOnlySolicitor: bool;
+   isVerified: bool;
+   lawFirmAddress: opt text;
+   lawFirmName: opt text;
+   managedBySolicitor: opt principal;
+   mobile: text;
+   name: text;
+   "principal": principal;
+   role: opt UserRole;
+   solicitorLicenseNumber: opt text;
+   userType: UserType;
+ };
+type TransactionProgress = 
+ record {
+   blockingParties: vec principal;
+   completionPercentage: nat;
+   members: vec TransactionMember;
+   membersComplete: nat;
+   readyToExchange: bool;
+   totalMembers: nat;
+   transactionId: text;
+ };
+type TransactionMember = 
+ record {
+   canInviteOthers: bool;
+   canViewProgress: bool;
+   documentsComplete: bool;
+   joinedAt: Time;
+   lastActivityAt: Time;
+   "principal": principal;
+   requiredDocuments: vec text;
+   role: UserType;
+   transactionId: text;
+   uploadedDocuments: vec text;
+ };
+type Time = int;
+type Permission = 
+ variant {
+   AdminManageUsers;
+   AdminViewAllTransactions;
+   InvitePartyToTransaction: text;
+   ManageClientAccess: principal;
+   UpdateMemberDocuments: record {
+                            text;
+                            principal;
+                          };
+   ViewDevelopmentUnits: text;
+   ViewSharedTransaction: text;
+   ViewTransactionProgress: text;
+ };
+type AuditLog = 
+ record {
+   action: text;
+   actorPrincipal: principal;
+   id: nat;
+   metadata: text;
+   success: bool;
+   targetPrincipal: opt principal;
+   timestamp: Time;
+   transactionId: opt text;
+ };
+service : {
+  addTransactionMember: (transactionId: text, memberPrincipal: principal,
+   role: UserType, canViewProgress: bool, canInviteOthers: bool, csrfToken:
+   text) -> (bool);
+  amIAdmin: () -> (bool) query;
+  bootstrapAdmin: (name: text, email: text) -> (bool);
+  canUserAccessTransaction: (user: principal, txId: text) -> (bool) query;
+  checkPermissionWithAudit: (permission: Permission) -> (bool);
+  createUserForPrincipal: (targetPrincipal: principal, name: text, email:
+   text, mobile: text, userTypeText: text, csrfToken: text) -> (bool);
+  deleteUserByPrincipal: (targetPrincipal: principal, csrfToken: text) ->
+   (bool);
+  generateCSRFToken: () -> (text);
+  getAllUsers: () -> (vec UserProfile) query;
+  getAuditLogs: (limit: nat) -> (vec AuditLog) query;
+  getCSRFToken: () -> (opt text) query;
+  getCycles: () -> (nat) query;
+  getMyManagingSolicitor: () -> (opt UserProfile) query;
+  getMyProfile: () -> (opt UserProfile) query;
+  getMyProfileUpdate: () -> (opt UserProfile);
+  getMySolicitorClients: () -> (vec UserProfile) query;
+  getTransactionMembers: (transactionId: text) ->
+   (opt vec TransactionMember) query;
+  getTransactionProgress: (transactionId: text) ->
+   (opt TransactionProgress) query;
+  getUserProfile: ("principal": principal) -> (opt UserProfile) query;
+  hasPermission: (permission: Permission) -> (bool) query;
+  initializeKnownAdmin: (name: text, email: text, mobile: text) -> (bool);
+  linkSolicitorToClient: (solicitorPrincipal: principal, consentGiven: 
+   bool, csrfToken: text) -> (bool);
+  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);
+  resendVerificationEmail: (csrfToken: text) -> (bool);
+  revokeSolicitorAccess: (solicitorPrincipal: principal, csrfToken: text) ->
+   (bool);
+  updateMemberDocuments: (transactionId: text, uploadedDocumentName: 
+   text, csrfToken: text) -> (bool);
+  updateTransactionMemberRequiredDocs: (transactionId: text,
+   documentsToRemove: vec text, csrfToken: text) -> (bool);
+  upgradeToAdmin: (targetPrincipal: principal, csrfToken: text) -> (bool);
+  validateAdmin: ("principal": principal) -> (bool) query;
+  validateCSRFToken: (token: text) -> (bool);
+  verifyEmail: (token: text, csrfToken: text) -> (bool);
+  verifyUser: (userPrincipal: principal, csrfToken: text) -> (bool);
+  whoAmI: () -> (principal) query;
+}

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

@@ -0,0 +1,148 @@
+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,
+  'targetPrincipal' : [] | [Principal],
+  'timestamp' : Time,
+  'success' : boolean,
+  'actorPrincipal' : Principal,
+  'transactionId' : [] | [string],
+}
+export type Permission = { 'ViewTransactionProgress' : string } |
+  { 'ViewSharedTransaction' : string } |
+  { 'ViewDevelopmentUnits' : string } |
+  { 'ManageClientAccess' : Principal } |
+  { 'InvitePartyToTransaction' : string } |
+  { 'AdminViewAllTransactions' : null } |
+  { 'AdminManageUsers' : null } |
+  { 'UpdateMemberDocuments' : [string, Principal] };
+export type Time = bigint;
+export interface TransactionMember {
+  'uploadedDocuments' : Array<string>,
+  'principal' : Principal,
+  'requiredDocuments' : Array<string>,
+  'joinedAt' : Time,
+  'role' : UserType,
+  'documentsComplete' : boolean,
+  'canViewProgress' : boolean,
+  'canInviteOthers' : boolean,
+  'lastActivityAt' : Time,
+  'transactionId' : string,
+}
+export interface TransactionProgress {
+  'members' : Array<TransactionMember>,
+  'completionPercentage' : bigint,
+  'readyToExchange' : boolean,
+  'membersComplete' : bigint,
+  'totalMembers' : bigint,
+  'blockingParties' : Array<Principal>,
+  'transactionId' : string,
+}
+export interface UserProfile {
+  'isPlatformOnlySolicitor' : boolean,
+  'userType' : UserType,
+  'principal' : Principal,
+  'managedBySolicitor' : [] | [Principal],
+  'emailVerified' : boolean,
+  'name' : string,
+  'createdAt' : Time,
+  'role' : [] | [UserRole],
+  'email' : string,
+  'lawFirmName' : [] | [string],
+  'isVerified' : boolean,
+  'clientPrincipals' : Array<Principal>,
+  'emailVerificationSentAt' : [] | [Time],
+  'emailVerificationToken' : [] | [string],
+  'mobile' : string,
+  'solicitorLicenseNumber' : [] | [string],
+  'lawFirmAddress' : [] | [string],
+}
+export type UserRole = { 'admin' : null } |
+  { 'solicitor' : null } |
+  { 'seller' : null } |
+  { 'guest' : null } |
+  { 'buyer' : null };
+export type UserType = { 'solicitor_platform_only' : null } |
+  { 'admin' : null } |
+  { 'diy_buyer' : null } |
+  { 'solicitor_transparent' : null } |
+  { 'platform_admin' : null } |
+  { 'solicitor_client_linked' : null } |
+  { 'estate_agent' : null } |
+  { 'platform_support' : null } |
+  { 'mortgage_broker' : null } |
+  { 'seller' : null } |
+  { 'conveyancer_managed' : null } |
+  { 'diy_seller' : null } |
+  { 'assisted_seller' : null } |
+  { 'conveyancer_transparent' : null } |
+  { 'buyer' : null } |
+  { 'property_developer' : null } |
+  { 'solicitor_managed' : null } |
+  { 'assisted_buyer' : null };
+export interface _SERVICE {
+  'addTransactionMember' : ActorMethod<
+    [string, Principal, UserType, boolean, boolean, string],
+    boolean
+  >,
+  'amIAdmin' : ActorMethod<[], boolean>,
+  'bootstrapAdmin' : ActorMethod<[string, string], boolean>,
+  'canUserAccessTransaction' : ActorMethod<[Principal, string], boolean>,
+  'checkPermissionWithAudit' : ActorMethod<[Permission], boolean>,
+  'createUserForPrincipal' : ActorMethod<
+    [Principal, string, string, string, string, string],
+    boolean
+  >,
+  'deleteUserByPrincipal' : ActorMethod<[Principal, string], boolean>,
+  'generateCSRFToken' : ActorMethod<[], string>,
+  'getAllUsers' : ActorMethod<[], Array<UserProfile>>,
+  'getAuditLogs' : ActorMethod<[bigint], Array<AuditLog>>,
+  'getCSRFToken' : ActorMethod<[], [] | [string]>,
+  'getCycles' : ActorMethod<[], bigint>,
+  'getMyManagingSolicitor' : ActorMethod<[], [] | [UserProfile]>,
+  'getMyProfile' : ActorMethod<[], [] | [UserProfile]>,
+  'getMyProfileUpdate' : ActorMethod<[], [] | [UserProfile]>,
+  'getMySolicitorClients' : ActorMethod<[], Array<UserProfile>>,
+  'getTransactionMembers' : ActorMethod<
+    [string],
+    [] | [Array<TransactionMember>]
+  >,
+  'getTransactionProgress' : ActorMethod<[string], [] | [TransactionProgress]>,
+  'getUserProfile' : ActorMethod<[Principal], [] | [UserProfile]>,
+  'hasPermission' : ActorMethod<[Permission], boolean>,
+  'initializeKnownAdmin' : ActorMethod<[string, string, string], boolean>,
+  'linkSolicitorToClient' : ActorMethod<[Principal, boolean, string], boolean>,
+  'registerUser' : ActorMethod<[string, string, string, string], boolean>,
+  'registerUserV2' : ActorMethod<
+    [
+      string,
+      string,
+      string,
+      UserType,
+      [] | [string],
+      [] | [string],
+      [] | [string],
+      string,
+    ],
+    boolean
+  >,
+  'resendVerificationEmail' : ActorMethod<[string], boolean>,
+  'revokeSolicitorAccess' : ActorMethod<[Principal, string], boolean>,
+  'updateMemberDocuments' : ActorMethod<[string, string, string], boolean>,
+  'updateTransactionMemberRequiredDocs' : ActorMethod<
+    [string, Array<string>, string],
+    boolean
+  >,
+  'upgradeToAdmin' : ActorMethod<[Principal, string], boolean>,
+  'validateAdmin' : ActorMethod<[Principal], boolean>,
+  'validateCSRFToken' : ActorMethod<[string], boolean>,
+  'verifyEmail' : ActorMethod<[string, string], boolean>,
+  'verifyUser' : ActorMethod<[Principal, string], boolean>,
+  'whoAmI' : ActorMethod<[], Principal>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/src/canisters/user_management/user_management.did.js

@@ -0,0 +1,192 @@
+export const idlFactory = ({ IDL }) => {
+  const UserType = IDL.Variant({
+    'solicitor_platform_only' : IDL.Null,
+    'admin' : IDL.Null,
+    'diy_buyer' : IDL.Null,
+    'solicitor_transparent' : IDL.Null,
+    'platform_admin' : IDL.Null,
+    'solicitor_client_linked' : IDL.Null,
+    'estate_agent' : IDL.Null,
+    'platform_support' : IDL.Null,
+    'mortgage_broker' : IDL.Null,
+    'seller' : IDL.Null,
+    'conveyancer_managed' : IDL.Null,
+    'diy_seller' : IDL.Null,
+    'assisted_seller' : IDL.Null,
+    'conveyancer_transparent' : IDL.Null,
+    'buyer' : IDL.Null,
+    'property_developer' : IDL.Null,
+    'solicitor_managed' : IDL.Null,
+    'assisted_buyer' : IDL.Null,
+  });
+  const Permission = IDL.Variant({
+    'ViewTransactionProgress' : IDL.Text,
+    'ViewSharedTransaction' : IDL.Text,
+    'ViewDevelopmentUnits' : IDL.Text,
+    'ManageClientAccess' : IDL.Principal,
+    'InvitePartyToTransaction' : IDL.Text,
+    'AdminViewAllTransactions' : IDL.Null,
+    'AdminManageUsers' : IDL.Null,
+    'UpdateMemberDocuments' : IDL.Tuple(IDL.Text, IDL.Principal),
+  });
+  const Time = IDL.Int;
+  const UserRole = IDL.Variant({
+    'admin' : IDL.Null,
+    'solicitor' : IDL.Null,
+    'seller' : IDL.Null,
+    'guest' : IDL.Null,
+    'buyer' : IDL.Null,
+  });
+  const UserProfile = IDL.Record({
+    'isPlatformOnlySolicitor' : IDL.Bool,
+    'userType' : UserType,
+    'principal' : IDL.Principal,
+    'managedBySolicitor' : IDL.Opt(IDL.Principal),
+    'emailVerified' : IDL.Bool,
+    'name' : IDL.Text,
+    'createdAt' : Time,
+    'role' : IDL.Opt(UserRole),
+    'email' : IDL.Text,
+    'lawFirmName' : IDL.Opt(IDL.Text),
+    'isVerified' : IDL.Bool,
+    'clientPrincipals' : IDL.Vec(IDL.Principal),
+    'emailVerificationSentAt' : IDL.Opt(Time),
+    'emailVerificationToken' : IDL.Opt(IDL.Text),
+    'mobile' : IDL.Text,
+    'solicitorLicenseNumber' : IDL.Opt(IDL.Text),
+    'lawFirmAddress' : IDL.Opt(IDL.Text),
+  });
+  const AuditLog = IDL.Record({
+    'id' : IDL.Nat,
+    'action' : IDL.Text,
+    'metadata' : IDL.Text,
+    'targetPrincipal' : IDL.Opt(IDL.Principal),
+    'timestamp' : Time,
+    'success' : IDL.Bool,
+    'actorPrincipal' : IDL.Principal,
+    'transactionId' : IDL.Opt(IDL.Text),
+  });
+  const TransactionMember = IDL.Record({
+    'uploadedDocuments' : IDL.Vec(IDL.Text),
+    'principal' : IDL.Principal,
+    'requiredDocuments' : IDL.Vec(IDL.Text),
+    'joinedAt' : Time,
+    'role' : UserType,
+    'documentsComplete' : IDL.Bool,
+    'canViewProgress' : IDL.Bool,
+    'canInviteOthers' : IDL.Bool,
+    'lastActivityAt' : Time,
+    'transactionId' : IDL.Text,
+  });
+  const TransactionProgress = IDL.Record({
+    'members' : IDL.Vec(TransactionMember),
+    'completionPercentage' : IDL.Nat,
+    'readyToExchange' : IDL.Bool,
+    'membersComplete' : IDL.Nat,
+    'totalMembers' : IDL.Nat,
+    'blockingParties' : IDL.Vec(IDL.Principal),
+    'transactionId' : IDL.Text,
+  });
+  return IDL.Service({
+    'addTransactionMember' : IDL.Func(
+        [IDL.Text, IDL.Principal, UserType, IDL.Bool, IDL.Bool, IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'amIAdmin' : IDL.Func([], [IDL.Bool], ['query']),
+    'bootstrapAdmin' : IDL.Func([IDL.Text, IDL.Text], [IDL.Bool], []),
+    'canUserAccessTransaction' : IDL.Func(
+        [IDL.Principal, IDL.Text],
+        [IDL.Bool],
+        ['query'],
+      ),
+    'checkPermissionWithAudit' : IDL.Func([Permission], [IDL.Bool], []),
+    'createUserForPrincipal' : IDL.Func(
+        [IDL.Principal, IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'deleteUserByPrincipal' : IDL.Func(
+        [IDL.Principal, IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'generateCSRFToken' : IDL.Func([], [IDL.Text], []),
+    'getAllUsers' : IDL.Func([], [IDL.Vec(UserProfile)], ['query']),
+    'getAuditLogs' : IDL.Func([IDL.Nat], [IDL.Vec(AuditLog)], ['query']),
+    'getCSRFToken' : IDL.Func([], [IDL.Opt(IDL.Text)], ['query']),
+    'getCycles' : IDL.Func([], [IDL.Nat], ['query']),
+    'getMyManagingSolicitor' : IDL.Func([], [IDL.Opt(UserProfile)], ['query']),
+    'getMyProfile' : IDL.Func([], [IDL.Opt(UserProfile)], ['query']),
+    'getMyProfileUpdate' : IDL.Func([], [IDL.Opt(UserProfile)], []),
+    'getMySolicitorClients' : IDL.Func([], [IDL.Vec(UserProfile)], ['query']),
+    'getTransactionMembers' : IDL.Func(
+        [IDL.Text],
+        [IDL.Opt(IDL.Vec(TransactionMember))],
+        ['query'],
+      ),
+    'getTransactionProgress' : IDL.Func(
+        [IDL.Text],
+        [IDL.Opt(TransactionProgress)],
+        ['query'],
+      ),
+    'getUserProfile' : IDL.Func(
+        [IDL.Principal],
+        [IDL.Opt(UserProfile)],
+        ['query'],
+      ),
+    'hasPermission' : IDL.Func([Permission], [IDL.Bool], ['query']),
+    'initializeKnownAdmin' : IDL.Func(
+        [IDL.Text, IDL.Text, IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'linkSolicitorToClient' : IDL.Func(
+        [IDL.Principal, IDL.Bool, IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'registerUser' : IDL.Func(
+        [IDL.Text, IDL.Text, IDL.Text, IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'registerUserV2' : IDL.Func(
+        [
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          UserType,
+          IDL.Opt(IDL.Text),
+          IDL.Opt(IDL.Text),
+          IDL.Opt(IDL.Text),
+          IDL.Text,
+        ],
+        [IDL.Bool],
+        [],
+      ),
+    'resendVerificationEmail' : IDL.Func([IDL.Text], [IDL.Bool], []),
+    'revokeSolicitorAccess' : IDL.Func(
+        [IDL.Principal, IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'updateMemberDocuments' : IDL.Func(
+        [IDL.Text, IDL.Text, IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'updateTransactionMemberRequiredDocs' : IDL.Func(
+        [IDL.Text, IDL.Vec(IDL.Text), IDL.Text],
+        [IDL.Bool],
+        [],
+      ),
+    'upgradeToAdmin' : IDL.Func([IDL.Principal, IDL.Text], [IDL.Bool], []),
+    'validateAdmin' : IDL.Func([IDL.Principal], [IDL.Bool], ['query']),
+    'validateCSRFToken' : IDL.Func([IDL.Text], [IDL.Bool], []),
+    'verifyEmail' : IDL.Func([IDL.Text, IDL.Text], [IDL.Bool], []),
+    'verifyUser' : IDL.Func([IDL.Principal, IDL.Text], [IDL.Bool], []),
+    'whoAmI' : IDL.Func([], [IDL.Principal], ['query']),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/src/client.ts

@@ -0,0 +1,77 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+import { idlFactory as transactionManagerIdl } from "./canisters/transaction_manager/index.js";
+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 type {
+  TransactionManagerService,
+  DocumentStorageService,
+  UserManagementService,
+  LedgerManagerService,
+} from "./types.js";
+import {
+  MAINNET_CANISTER_IDS,
+  type CanisterIds,
+  type PropXchainClientOptions,
+  type IPropXchainClient,
+} from "./types.js";
+import {
+  createAuditTrailStub,
+  createAgentHarnessStub,
+  type AuditTrailStub,
+  type AgentHarnessStub,
+} from "./stubs.js";
+import { wrapAgentError } from "./errors.js";
+
+const DEFAULT_HOST = "https://icp-api.io";
+
+export class PropXchainClient implements IPropXchainClient {
+  readonly transactionManager: TransactionManagerService;
+  readonly documentStorage: DocumentStorageService;
+  readonly userManagement: UserManagementService;
+  readonly ledgerManager: LedgerManagerService;
+  readonly auditTrail: AuditTrailStub;
+  readonly agentHarness: AgentHarnessStub;
+
+  constructor(options: PropXchainClientOptions = {}) {
+    const canisterIds: CanisterIds = {
+      ...MAINNET_CANISTER_IDS,
+      ...options.canisterIds,
+    };
+
+    const agent =
+      options.agent ??
+      HttpAgent.createSync({
+        host: options.host ?? DEFAULT_HOST,
+        identity: options.identity,
+      });
+
+    const isLocal = options.fetchRootKey ?? /127\.0\.0\.1|localhost/.test(
+      options.host ?? "",
+    );
+    if (isLocal) {
+      agent.fetchRootKey().catch((err) => {
+        throw wrapAgentError(err);
+      });
+    }
+
+    this.transactionManager = Actor.createActor<TransactionManagerService>(
+      transactionManagerIdl,
+      { agent, canisterId: canisterIds.transactionManager },
+    );
+    this.documentStorage = Actor.createActor<DocumentStorageService>(
+      documentStorageIdl,
+      { agent, canisterId: canisterIds.documentStorage },
+    );
+    this.userManagement = Actor.createActor<UserManagementService>(
+      userManagementIdl,
+      { agent, canisterId: canisterIds.userManagement },
+    );
+    this.ledgerManager = Actor.createActor<LedgerManagerService>(
+      ledgerManagerIdl,
+      { agent, canisterId: canisterIds.ledgerManager },
+    );
+    this.auditTrail = createAuditTrailStub();
+    this.agentHarness = createAgentHarnessStub();
+  }
+}

package/src/errors.ts

@@ -0,0 +1,31 @@
+export type CoreClientErrorCode =
+  | "NETWORK"
+  | "CANISTER_REJECT"
+  | "UNAUTHENTICATED"
+  | "TIMEOUT"
+  | "INVALID_ARGUMENT"
+  | "UNKNOWN";
+
+export class CoreClientError extends Error {
+  readonly code: CoreClientErrorCode;
+  readonly cause?: unknown;
+
+  constructor(code: CoreClientErrorCode, message: string, cause?: unknown) {
+    super(message);
+    this.name = "CoreClientError";
+    this.code = code;
+    this.cause = cause;
+  }
+}
+
+export function wrapAgentError(err: unknown): CoreClientError {
+  if (err instanceof CoreClientError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  const code: CoreClientErrorCode =
+    /reject|trapped/i.test(message) ? "CANISTER_REJECT" :
+    /timeout|timed out/i.test(message) ? "TIMEOUT" :
+    /unauthoriz|unauthent|anonymous/i.test(message) ? "UNAUTHENTICATED" :
+    /network|fetch/i.test(message) ? "NETWORK" :
+    "UNKNOWN";
+  return new CoreClientError(code, message, err);
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+export { PropXchainClient } from "./client.js";
+export {
+  MockPropXchainClient,
+  isMockEnabled,
+  MOCK_ENV_FLAG,
+} from "./mock.js";
+export {
+  CoreClientError,
+  wrapAgentError,
+  type CoreClientErrorCode,
+} from "./errors.js";
+export { withRetry, type RetryOptions } from "./retry.js";
+export {
+  createAuditTrailStub,
+  createAgentHarnessStub,
+  type AuditTrailStub,
+  type AgentHarnessStub,
+  type AuditEvent,
+  type AuditFilter,
+} from "./stubs.js";
+export {
+  MAINNET_CANISTER_IDS,
+  type CanisterIds,
+  type IPropXchainClient,
+  type PropXchainClientOptions,
+  type TransactionManagerService,
+  type DocumentStorageService,
+  type UserManagementService,
+  type LedgerManagerService,
+} from "./types.js";