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

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

@@ -0,0 +1,45 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
+
+export type ContactType = { 'support' : null } |
+  { 'partners' : null } |
+  { 'sales' : null };
+export interface EmailNotification {
+  'id' : bigint,
+  'userType' : [] | [string],
+  'contactType' : ContactType,
+  'subject' : string,
+  'partnerType' : [] | [string],
+  'name' : string,
+  'volume' : [] | [string],
+  'email' : string,
+  'website' : [] | [string],
+  'company' : [] | [string],
+  'message' : string,
+  'timestamp' : bigint,
+  'phone' : [] | [string],
+  'processed' : boolean,
+}
+export interface _SERVICE {
+  'formatNotificationAsEmail' : ActorMethod<[bigint], [] | [string]>,
+  'getAllNotifications' : ActorMethod<[], Array<EmailNotification>>,
+  'getNotification' : ActorMethod<[bigint], [] | [EmailNotification]>,
+  'getUnprocessedCount' : ActorMethod<[], bigint>,
+  'getUnprocessedNotifications' : ActorMethod<[], Array<EmailNotification>>,
+  'markAsProcessed' : ActorMethod<[bigint], boolean>,
+  'submitPartnerInquiry' : ActorMethod<
+    [string, string, string, string, string, string],
+    bigint
+  >,
+  'submitSalesInquiry' : ActorMethod<
+    [string, string, string, string, string, string, string],
+    bigint
+  >,
+  'submitSupportRequest' : ActorMethod<
+    [string, string, string, string],
+    bigint
+  >,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/src/canisters/email_service/email_service.did.js

@@ -0,0 +1,63 @@
+export const idlFactory = ({ IDL }) => {
+  const ContactType = IDL.Variant({
+    'support' : IDL.Null,
+    'partners' : IDL.Null,
+    'sales' : IDL.Null,
+  });
+  const EmailNotification = IDL.Record({
+    'id' : IDL.Nat,
+    'userType' : IDL.Opt(IDL.Text),
+    'contactType' : ContactType,
+    'subject' : IDL.Text,
+    'partnerType' : IDL.Opt(IDL.Text),
+    'name' : IDL.Text,
+    'volume' : IDL.Opt(IDL.Text),
+    'email' : IDL.Text,
+    'website' : IDL.Opt(IDL.Text),
+    'company' : IDL.Opt(IDL.Text),
+    'message' : IDL.Text,
+    'timestamp' : IDL.Int,
+    'phone' : IDL.Opt(IDL.Text),
+    'processed' : IDL.Bool,
+  });
+  return IDL.Service({
+    'formatNotificationAsEmail' : IDL.Func(
+        [IDL.Nat],
+        [IDL.Opt(IDL.Text)],
+        ['query'],
+      ),
+    'getAllNotifications' : IDL.Func(
+        [],
+        [IDL.Vec(EmailNotification)],
+        ['query'],
+      ),
+    'getNotification' : IDL.Func(
+        [IDL.Nat],
+        [IDL.Opt(EmailNotification)],
+        ['query'],
+      ),
+    'getUnprocessedCount' : IDL.Func([], [IDL.Nat], ['query']),
+    'getUnprocessedNotifications' : IDL.Func(
+        [],
+        [IDL.Vec(EmailNotification)],
+        ['query'],
+      ),
+    'markAsProcessed' : IDL.Func([IDL.Nat], [IDL.Bool], []),
+    'submitPartnerInquiry' : IDL.Func(
+        [IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text],
+        [IDL.Nat],
+        [],
+      ),
+    'submitSalesInquiry' : IDL.Func(
+        [IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text, IDL.Text],
+        [IDL.Nat],
+        [],
+      ),
+    'submitSupportRequest' : IDL.Func(
+        [IDL.Text, IDL.Text, IDL.Text, IDL.Text],
+        [IDL.Nat],
+        [],
+      ),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/src/canisters/email_service/index.ts

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

package/src/canisters/land_registry_integration/index.ts

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

package/src/canisters/land_registry_integration/land_registry_integration.did

@@ -0,0 +1,169 @@
+type TransactionStatus = 
+ variant {
+   confirmed;
+   failed;
+   pending_api_call;
+   requires_manual_review;
+   sent_to_lr;
+ };
+type Result_4 = 
+ variant {
+   err: text;
+   ok: LandRegistryAPIResponse;
+ };
+type Result_3 = 
+ variant {
+   err: text;
+   ok: nat32;
+ };
+type Result_2 = 
+ variant {
+   err: text;
+   ok: OwnershipTransferPayload;
+ };
+type Result_1 = 
+ variant {
+   err: text;
+   ok: text;
+ };
+type Result = 
+ variant {
+   err: text;
+   ok: bool;
+ };
+type Period = 
+ variant {
+   day;
+   month;
+   week;
+   year;
+ };
+type OwnershipTransferPayload = 
+ record {
+   blockchainCompletionProof: text;
+   blockchainCompletionTimestamp: int;
+   blockchainProofHash: text;
+   buyerSolicitorSignature: text;
+   contractExchangeTimestamp: int;
+   conveyancerDetails: ConveyancerInfo;
+   newOwnerDetails: NewOwnerInfo;
+   postcode: text;
+   previousOwner: text;
+   propertyAddress: text;
+   sellerSolicitorSignature: text;
+   titleNumber: text;
+   transactionAmount: nat64;
+   transactionDate: int;
+   transferID: text;
+ };
+type NewOwnerInfo = 
+ record {
+   address: text;
+   contactEmail: text;
+   name: text;
+ };
+type LandRegistryTransactionRecord = 
+ record {
+   apiResponse: opt LandRegistryAPIResponse;
+   blockchainTransactionID: text;
+   createdAt: int;
+   landRegistryPayload: OwnershipTransferPayload;
+   lastUpdated: int;
+   maxRetries: nat32;
+   nextRetryTime: opt int;
+   retryCount: nat32;
+   status: TransactionStatus;
+   transactionID: text;
+ };
+type LandRegistryStats = 
+ record {
+   avgTimeToRegistration: nat32;
+   failed: nat32;
+   pending: nat32;
+   successful: nat32;
+   totalSubmissions: nat32;
+ };
+type LandRegistryAPIResponse = 
+ record {
+   errorMessage: opt text;
+   estimatedCompletionTime: int;
+   landRegistryConfirmationNumber: text;
+   processedTimestamp: opt int;
+   receivedTimestamp: int;
+   registeredTimestamp: opt int;
+   responseID: text;
+   status: LRStatus;
+ };
+type LandRegistryAPICredentials = 
+ record {
+   apiEndpoint: text;
+   apiKey: text;
+   authenticationType: AuthenticationType;
+   environment: Environment;
+   lastValidated: int;
+ };
+type LRStatus = 
+ variant {
+   failed;
+   processing;
+   received;
+   registered;
+ };
+type Environment = 
+ variant {
+   production;
+   sandbox;
+ };
+type ConveyancerInfo = 
+ record {
+   contactEmail: text;
+   licenseNumber: text;
+   name: text;
+ };
+type AuthenticationType = 
+ variant {
+   api_key;
+   oauth2;
+ };
+service : {
+  check_land_registry_status: (transactionID: text) ->
+   (opt LandRegistryTransactionRecord) query;
+  configure_land_registry_api: (credentials: LandRegistryAPICredentials) ->
+   (Result_1);
+  getCycles: () -> (nat) query;
+  get_all_pending_land_registry_submissions: (companyAccountID: text) ->
+   (vec LandRegistryTransactionRecord) query;
+  get_all_transactions: () ->
+   (vec record {
+          text;
+          LandRegistryTransactionRecord;
+        }) query;
+  get_land_registry_stats: (companyAccountID: text, period: Period) ->
+   (LandRegistryStats) query;
+  get_land_registry_status: () ->
+   (opt
+     record {
+       apiEndpoint: text;
+       environment: Environment;
+       lastValidated: int;
+     }) query;
+  get_lr_response: (confirmationID: text) -> (Result_4) query;
+  log_land_registry_error: (transactionID: text, errorDetails: text) ->
+   (Result_3);
+  prepare_ownership_transfer_payload: (transactionID: text,
+   blockchainTransactionID: text, propertyAddress: text, postcode: text,
+   titleNumber: text, previousOwner: text, newOwnerDetails: NewOwnerInfo,
+   conveyancerDetails: ConveyancerInfo, transactionAmount: nat64,
+   buyerSolicitorSignature: text, sellerSolicitorSignature: text,
+   blockchainProofHash: text, blockchainCompletionProof: text,
+   contractExchangeTimestamp: int, blockchainCompletionTimestamp: int) ->
+   (Result_2);
+  receive_land_registry_callback: (callbackData: LandRegistryAPIResponse) ->
+   (Result_1);
+  retry_failed_land_registry_transmission: (transactionID: text) ->
+   (Result_1);
+  send_to_land_registry: (transactionID: text) -> (Result_1);
+  simulate_land_registry_processing: (confirmationNumber: text) -> (Result_1);
+  validate_land_registry_connection: () -> (Result);
+  verify_land_registry_receipt: (transactionID: text) -> (Result);
+}

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

@@ -0,0 +1,157 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
+
+export type AuthenticationType = { 'api_key' : null } |
+  { 'oauth2' : null };
+export interface ConveyancerInfo {
+  'name' : string,
+  'contactEmail' : string,
+  'licenseNumber' : string,
+}
+export type Environment = { 'sandbox' : null } |
+  { 'production' : null };
+export type LRStatus = { 'processing' : null } |
+  { 'received' : null } |
+  { 'failed' : null } |
+  { 'registered' : null };
+export interface LandRegistryAPICredentials {
+  'authenticationType' : AuthenticationType,
+  'lastValidated' : bigint,
+  'apiEndpoint' : string,
+  'apiKey' : string,
+  'environment' : Environment,
+}
+export interface LandRegistryAPIResponse {
+  'status' : LRStatus,
+  'registeredTimestamp' : [] | [bigint],
+  'processedTimestamp' : [] | [bigint],
+  'errorMessage' : [] | [string],
+  'receivedTimestamp' : bigint,
+  'responseID' : string,
+  'estimatedCompletionTime' : bigint,
+  'landRegistryConfirmationNumber' : string,
+}
+export interface LandRegistryStats {
+  'pending' : number,
+  'totalSubmissions' : number,
+  'avgTimeToRegistration' : number,
+  'successful' : number,
+  'failed' : number,
+}
+export interface LandRegistryTransactionRecord {
+  'status' : TransactionStatus,
+  'createdAt' : bigint,
+  'lastUpdated' : bigint,
+  'maxRetries' : number,
+  'landRegistryPayload' : OwnershipTransferPayload,
+  'retryCount' : number,
+  'nextRetryTime' : [] | [bigint],
+  'blockchainTransactionID' : string,
+  'apiResponse' : [] | [LandRegistryAPIResponse],
+  'transactionID' : string,
+}
+export interface NewOwnerInfo {
+  'name' : string,
+  'address' : string,
+  'contactEmail' : string,
+}
+export interface OwnershipTransferPayload {
+  'transactionDate' : bigint,
+  'postcode' : string,
+  'sellerSolicitorSignature' : string,
+  'buyerSolicitorSignature' : string,
+  'titleNumber' : string,
+  'newOwnerDetails' : NewOwnerInfo,
+  'blockchainCompletionProof' : string,
+  'previousOwner' : string,
+  'propertyAddress' : string,
+  'contractExchangeTimestamp' : bigint,
+  'blockchainProofHash' : string,
+  'transactionAmount' : bigint,
+  'transferID' : string,
+  'conveyancerDetails' : ConveyancerInfo,
+  'blockchainCompletionTimestamp' : bigint,
+}
+export type Period = { 'day' : null } |
+  { 'month' : null } |
+  { 'week' : null } |
+  { 'year' : null };
+export type Result = { 'ok' : boolean } |
+  { 'err' : string };
+export type Result_1 = { 'ok' : string } |
+  { 'err' : string };
+export type Result_2 = { 'ok' : OwnershipTransferPayload } |
+  { 'err' : string };
+export type Result_3 = { 'ok' : number } |
+  { 'err' : string };
+export type Result_4 = { 'ok' : LandRegistryAPIResponse } |
+  { 'err' : string };
+export type TransactionStatus = { 'sent_to_lr' : null } |
+  { 'requires_manual_review' : null } |
+  { 'pending_api_call' : null } |
+  { 'confirmed' : null } |
+  { 'failed' : null };
+export interface _SERVICE {
+  'check_land_registry_status' : ActorMethod<
+    [string],
+    [] | [LandRegistryTransactionRecord]
+  >,
+  'configure_land_registry_api' : ActorMethod<
+    [LandRegistryAPICredentials],
+    Result_1
+  >,
+  'getCycles' : ActorMethod<[], bigint>,
+  'get_all_pending_land_registry_submissions' : ActorMethod<
+    [string],
+    Array<LandRegistryTransactionRecord>
+  >,
+  'get_all_transactions' : ActorMethod<
+    [],
+    Array<[string, LandRegistryTransactionRecord]>
+  >,
+  'get_land_registry_stats' : ActorMethod<[string, Period], LandRegistryStats>,
+  'get_land_registry_status' : ActorMethod<
+    [],
+    [] | [
+      {
+        'lastValidated' : bigint,
+        'apiEndpoint' : string,
+        'environment' : Environment,
+      }
+    ]
+  >,
+  'get_lr_response' : ActorMethod<[string], Result_4>,
+  'log_land_registry_error' : ActorMethod<[string, string], Result_3>,
+  'prepare_ownership_transfer_payload' : ActorMethod<
+    [
+      string,
+      string,
+      string,
+      string,
+      string,
+      string,
+      NewOwnerInfo,
+      ConveyancerInfo,
+      bigint,
+      string,
+      string,
+      string,
+      string,
+      bigint,
+      bigint,
+    ],
+    Result_2
+  >,
+  'receive_land_registry_callback' : ActorMethod<
+    [LandRegistryAPIResponse],
+    Result_1
+  >,
+  'retry_failed_land_registry_transmission' : ActorMethod<[string], Result_1>,
+  'send_to_land_registry' : ActorMethod<[string], Result_1>,
+  'simulate_land_registry_processing' : ActorMethod<[string], Result_1>,
+  'validate_land_registry_connection' : ActorMethod<[], Result>,
+  'verify_land_registry_receipt' : ActorMethod<[string], Result>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/src/canisters/land_registry_integration/land_registry_integration.did.js

@@ -0,0 +1,182 @@
+export const idlFactory = ({ IDL }) => {
+  const TransactionStatus = IDL.Variant({
+    'sent_to_lr' : IDL.Null,
+    'requires_manual_review' : IDL.Null,
+    'pending_api_call' : IDL.Null,
+    'confirmed' : IDL.Null,
+    'failed' : IDL.Null,
+  });
+  const NewOwnerInfo = IDL.Record({
+    'name' : IDL.Text,
+    'address' : IDL.Text,
+    'contactEmail' : IDL.Text,
+  });
+  const ConveyancerInfo = IDL.Record({
+    'name' : IDL.Text,
+    'contactEmail' : IDL.Text,
+    'licenseNumber' : IDL.Text,
+  });
+  const OwnershipTransferPayload = IDL.Record({
+    'transactionDate' : IDL.Int,
+    'postcode' : IDL.Text,
+    'sellerSolicitorSignature' : IDL.Text,
+    'buyerSolicitorSignature' : IDL.Text,
+    'titleNumber' : IDL.Text,
+    'newOwnerDetails' : NewOwnerInfo,
+    'blockchainCompletionProof' : IDL.Text,
+    'previousOwner' : IDL.Text,
+    'propertyAddress' : IDL.Text,
+    'contractExchangeTimestamp' : IDL.Int,
+    'blockchainProofHash' : IDL.Text,
+    'transactionAmount' : IDL.Nat64,
+    'transferID' : IDL.Text,
+    'conveyancerDetails' : ConveyancerInfo,
+    'blockchainCompletionTimestamp' : IDL.Int,
+  });
+  const LRStatus = IDL.Variant({
+    'processing' : IDL.Null,
+    'received' : IDL.Null,
+    'failed' : IDL.Null,
+    'registered' : IDL.Null,
+  });
+  const LandRegistryAPIResponse = IDL.Record({
+    'status' : LRStatus,
+    'registeredTimestamp' : IDL.Opt(IDL.Int),
+    'processedTimestamp' : IDL.Opt(IDL.Int),
+    'errorMessage' : IDL.Opt(IDL.Text),
+    'receivedTimestamp' : IDL.Int,
+    'responseID' : IDL.Text,
+    'estimatedCompletionTime' : IDL.Int,
+    'landRegistryConfirmationNumber' : IDL.Text,
+  });
+  const LandRegistryTransactionRecord = IDL.Record({
+    'status' : TransactionStatus,
+    'createdAt' : IDL.Int,
+    'lastUpdated' : IDL.Int,
+    'maxRetries' : IDL.Nat32,
+    'landRegistryPayload' : OwnershipTransferPayload,
+    'retryCount' : IDL.Nat32,
+    'nextRetryTime' : IDL.Opt(IDL.Int),
+    'blockchainTransactionID' : IDL.Text,
+    'apiResponse' : IDL.Opt(LandRegistryAPIResponse),
+    'transactionID' : IDL.Text,
+  });
+  const AuthenticationType = IDL.Variant({
+    'api_key' : IDL.Null,
+    'oauth2' : IDL.Null,
+  });
+  const Environment = IDL.Variant({
+    'sandbox' : IDL.Null,
+    'production' : IDL.Null,
+  });
+  const LandRegistryAPICredentials = IDL.Record({
+    'authenticationType' : AuthenticationType,
+    'lastValidated' : IDL.Int,
+    'apiEndpoint' : IDL.Text,
+    'apiKey' : IDL.Text,
+    'environment' : Environment,
+  });
+  const Result_1 = IDL.Variant({ 'ok' : IDL.Text, 'err' : IDL.Text });
+  const Period = IDL.Variant({
+    'day' : IDL.Null,
+    'month' : IDL.Null,
+    'week' : IDL.Null,
+    'year' : IDL.Null,
+  });
+  const LandRegistryStats = IDL.Record({
+    'pending' : IDL.Nat32,
+    'totalSubmissions' : IDL.Nat32,
+    'avgTimeToRegistration' : IDL.Nat32,
+    'successful' : IDL.Nat32,
+    'failed' : IDL.Nat32,
+  });
+  const Result_4 = IDL.Variant({
+    'ok' : LandRegistryAPIResponse,
+    'err' : IDL.Text,
+  });
+  const Result_3 = IDL.Variant({ 'ok' : IDL.Nat32, 'err' : IDL.Text });
+  const Result_2 = IDL.Variant({
+    'ok' : OwnershipTransferPayload,
+    'err' : IDL.Text,
+  });
+  const Result = IDL.Variant({ 'ok' : IDL.Bool, 'err' : IDL.Text });
+  return IDL.Service({
+    'check_land_registry_status' : IDL.Func(
+        [IDL.Text],
+        [IDL.Opt(LandRegistryTransactionRecord)],
+        ['query'],
+      ),
+    'configure_land_registry_api' : IDL.Func(
+        [LandRegistryAPICredentials],
+        [Result_1],
+        [],
+      ),
+    'getCycles' : IDL.Func([], [IDL.Nat], ['query']),
+    'get_all_pending_land_registry_submissions' : IDL.Func(
+        [IDL.Text],
+        [IDL.Vec(LandRegistryTransactionRecord)],
+        ['query'],
+      ),
+    'get_all_transactions' : IDL.Func(
+        [],
+        [IDL.Vec(IDL.Tuple(IDL.Text, LandRegistryTransactionRecord))],
+        ['query'],
+      ),
+    'get_land_registry_stats' : IDL.Func(
+        [IDL.Text, Period],
+        [LandRegistryStats],
+        ['query'],
+      ),
+    'get_land_registry_status' : IDL.Func(
+        [],
+        [
+          IDL.Opt(
+            IDL.Record({
+              'lastValidated' : IDL.Int,
+              'apiEndpoint' : IDL.Text,
+              'environment' : Environment,
+            })
+          ),
+        ],
+        ['query'],
+      ),
+    'get_lr_response' : IDL.Func([IDL.Text], [Result_4], ['query']),
+    'log_land_registry_error' : IDL.Func([IDL.Text, IDL.Text], [Result_3], []),
+    'prepare_ownership_transfer_payload' : IDL.Func(
+        [
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          NewOwnerInfo,
+          ConveyancerInfo,
+          IDL.Nat64,
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          IDL.Text,
+          IDL.Int,
+          IDL.Int,
+        ],
+        [Result_2],
+        [],
+      ),
+    'receive_land_registry_callback' : IDL.Func(
+        [LandRegistryAPIResponse],
+        [Result_1],
+        [],
+      ),
+    'retry_failed_land_registry_transmission' : IDL.Func(
+        [IDL.Text],
+        [Result_1],
+        [],
+      ),
+    'send_to_land_registry' : IDL.Func([IDL.Text], [Result_1], []),
+    'simulate_land_registry_processing' : IDL.Func([IDL.Text], [Result_1], []),
+    'validate_land_registry_connection' : IDL.Func([], [Result], []),
+    'verify_land_registry_receipt' : IDL.Func([IDL.Text], [Result], []),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/src/canisters/property_registry/index.ts

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