@junobuild/admin 0.0.6 → 0.0.8

package/dist/declarations/internet_identity/internet_identity.did

@@ -23,6 +23,7 @@ type HttpResponse = record {
     status_code: nat16;
     headers: vec HeaderField;
     body: blob;
+    upgrade : opt bool;
     streaming_strategy: opt StreamingStrategy;
 };
 
@@ -72,6 +73,20 @@ type DeviceData = record {
     purpose: Purpose;
     key_type: KeyType;
     protection: DeviceProtection;
+    origin: opt text;
+};
+
+// The same as `DeviceData` but with the `last_usage` field.
+// This field cannot be written, hence the separate type.
+type DeviceWithUsage = record {
+    pubkey : DeviceKey;
+    alias : text;
+    credential_id : opt CredentialId;
+    purpose: Purpose;
+    key_type: KeyType;
+    protection: DeviceProtection;
+    origin: opt text;
+    last_usage: opt Timestamp;
 };
 
 type RegisterResponse = variant {
@@ -89,6 +104,7 @@ type AddTentativeDeviceResponse = variant {
     // The device was tentatively added.
     added_tentatively: record {
         verification_code: text;
+        // Expiration date, in nanos since the epoch
         device_registration_timeout: Timestamp;
     };
     // Device registration mode is off, either due to timeout or because it was never enabled.
@@ -138,6 +154,7 @@ type InternetIdentityStats = record {
     };
     archive_info: ArchiveInfo;
     canister_creation_cycles_cost: nat64;
+    active_anchor_stats: opt ActiveAnchorStatistics;
 };
 
 // Configuration parameters related to the archive.
@@ -148,28 +165,12 @@ type ArchiveConfig = record {
     module_hash : blob;
     // Buffered archive entries limit. If reached, II will stop accepting new anchor operations
     // until the buffered operations are acknowledged by the archive.
-    // Currently unused: in preparation of switching the archive integration to pull.
-    // Configured value will be discarded for storage_layout_version < 6.
     entries_buffer_limit: nat64;
     // The maximum number of entries to be transferred to the archive per call.
-    // Currently unused: in preparation of switching the archive integration to pull.
-    // Configured value will be discarded for storage_layout_version < 6.
     entries_fetch_limit: nat16;
     // Polling interval to fetch new entries from II (in nanoseconds).
     // Changes to this parameter will only take effect after an archive deployment.
-    // Currently unused: in preparation of switching the archive integration to pull.
-    // Configured value will be discarded for storage_layout_version < 6.
     polling_interval_ns: nat64;
-
-    // How the entries get transferred to the archive.
-    // This is opt, so that the config parameter can be removed after switching from push to pull.
-    // Configured value will be discarded for storage_layout_version < 6.
-    archive_integration: opt variant {
-        // II pushes the entries to the archive (legacy variant).
-        push;
-        // The archive pulls the entries from II.
-        pull;
-    }
 };
 
 // Information about the archive.
@@ -180,6 +181,41 @@ type ArchiveInfo = record {
     archive_config: opt ArchiveConfig;
 };
 
+// Rate limit configuration.
+// Currently only used for `register`.
+type RateLimitConfig = record {
+    // Time it takes (in ns) for a rate limiting token to be replenished.
+    time_per_token_ns : nat64;
+    // How many tokens are at most generated (to accommodate peaks).
+    max_tokens: nat64;
+};
+
+type ActiveAnchorStatistics = record {
+    // Stats for the last completed collection period for daily and monthly active anchors
+    completed: CompletedActiveAnchorStats;
+    // ongoing periods for daily and monthly active anchors
+    ongoing: OngoingActiveAnchorStats;
+};
+
+type CompletedActiveAnchorStats = record {
+    daily_active_anchors: opt ActiveAnchorCounter;
+    monthly_active_anchors: opt ActiveAnchorCounter;
+};
+
+type OngoingActiveAnchorStats = record {
+    // Ongoing active anchor counter for the current 24 h time bucket.
+    daily_active_anchors: ActiveAnchorCounter;
+    // Monthly active users are collected using 30-day sliding windows.
+    // This vec contains up to 30 30-day active windows each offset by one day.
+    // The vec is sorted, new collection windows are added at the end.
+    monthly_active_anchors: vec ActiveAnchorCounter;
+};
+
+type ActiveAnchorCounter = record {
+    start_timestamp: Timestamp;
+    counter: nat64;
+};
+
 // Init arguments of II which can be supplied on install and upgrade.
 // Setting a value to null keeps the previous value.
 type InternetIdentityInit = record {
@@ -197,8 +233,8 @@ type InternetIdentityInit = record {
     // The canister creation cost on mainnet is currently 100'000'000'000 cycles. If this value is higher thant the
     // canister creation cost, the newly created canister will keep extra cycles.
     canister_creation_cycles_cost : opt nat64;
-    // Config flag to upgrade the persistent state. If set to opt true it will migrate the storage layout to version 6.
-    upgrade_persistent_state: opt bool;
+    // Rate limit for the `register` call.
+    register_rate_limit : opt RateLimitConfig;
 };
 
 type ChallengeKey = text;
@@ -208,16 +244,36 @@ type ChallengeResult = record {
     chars : text;
 };
 
+// Extra information about registration status for new devices
 type DeviceRegistrationInfo = record {
+    // If present, the user has tentatively added a new device. This
+    // new device needs to be verified (see relevant endpoint) before
+    // 'expiration'.
     tentative_device : opt DeviceData;
+    // The timestamp at which the anchor will turn off registration mode
+    // (and the tentative device will be forgotten, if any, and if not verified)
     expiration: Timestamp;
 };
 
+// Information about the anchor
 type IdentityAnchorInfo = record {
-    devices : vec DeviceData;
+    // All devices that can authenticate to this anchor
+    devices : vec DeviceWithUsage;
+    // Device registration status used when adding devices, see DeviceRegistrationInfo
     device_registration: opt DeviceRegistrationInfo;
 };
 
+type AnchorCredentials = record {
+    credentials : vec WebAuthnCredential;
+    recovery_credentials : vec WebAuthnCredential;
+    recovery_phrases: vec PublicKey;
+};
+
+type WebAuthnCredential = record {
+    credential_id : CredentialId;
+    pubkey: PublicKey;
+};
+
 type DeployArchiveResult = variant {
     // The archive was deployed successfully and the supplied wasm module has been installed. The principal of the archive
     // canister is returned.
@@ -246,8 +302,10 @@ service : (opt InternetIdentityInit) -> {
     replace : (UserNumber, DeviceKey, DeviceData) -> ();
     remove : (UserNumber, DeviceKey) -> ();
     // Returns all devices of the user (authentication and recovery) but no information about device registrations.
-    // Note: Will be changed in the future to be more consistent with get_anchor_info.
+    // Note: Clears out the 'alias' fields on the devices. Use 'get_anchor_info' to obtain the full information.
+    // Deprecated: Use 'get_anchor_credentials' instead.
     lookup : (UserNumber) -> (vec DeviceData) query;
+    get_anchor_credentials : (UserNumber) -> (AnchorCredentials) query;
     get_anchor_info : (UserNumber) -> (IdentityAnchorInfo);
     get_principal : (UserNumber, FrontendHostname) -> (principal) query;
     stats : () -> (InternetIdentityStats) query;
@@ -261,6 +319,7 @@ service : (opt InternetIdentityInit) -> {
     get_delegation: (UserNumber, FrontendHostname, SessionKey, Timestamp) -> (GetDelegationResponse) query;
 
     http_request: (request: HttpRequest) -> (HttpResponse) query;
+    http_request_update: (request: HttpRequest) -> (HttpResponse);
 
     deploy_archive: (wasm: blob) -> (DeployArchiveResult);
     /// Returns a batch of entries _sorted by sequence number_ to be archived.

package/dist/declarations/internet_identity/internet_identity.did.d.ts

@@ -1,161 +1,204 @@
-import type {ActorMethod} from '@dfinity/agent';
-import type {Principal} from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { Principal } from '@dfinity/principal';
 
+export interface ActiveAnchorCounter {
+	counter: bigint;
+	start_timestamp: Timestamp;
+}
+export interface ActiveAnchorStatistics {
+	completed: CompletedActiveAnchorStats;
+	ongoing: OngoingActiveAnchorStats;
+}
 export type AddTentativeDeviceResponse =
-  | {
-      device_registration_mode_off: null;
-    }
-  | {another_device_tentatively_added: null}
-  | {
-      added_tentatively: {
-        verification_code: string;
-        device_registration_timeout: Timestamp;
-      };
-    };
+	| {
+			device_registration_mode_off: null;
+	  }
+	| { another_device_tentatively_added: null }
+	| {
+			added_tentatively: {
+				verification_code: string;
+				device_registration_timeout: Timestamp;
+			};
+	  };
+export interface AnchorCredentials {
+	recovery_phrases: Array<PublicKey>;
+	credentials: Array<WebAuthnCredential>;
+	recovery_credentials: Array<WebAuthnCredential>;
+}
 export interface ArchiveConfig {
-  polling_interval_ns: bigint;
-  entries_buffer_limit: bigint;
-  archive_integration: [] | [{pull: null} | {push: null}];
-  module_hash: Uint8Array | number[];
-  entries_fetch_limit: number;
+	polling_interval_ns: bigint;
+	entries_buffer_limit: bigint;
+	module_hash: Uint8Array | number[];
+	entries_fetch_limit: number;
 }
 export interface ArchiveInfo {
-  archive_config: [] | [ArchiveConfig];
-  archive_canister: [] | [Principal];
+	archive_config: [] | [ArchiveConfig];
+	archive_canister: [] | [Principal];
 }
 export interface BufferedArchiveEntry {
-  sequence_number: bigint;
-  entry: Uint8Array | number[];
-  anchor_number: UserNumber;
-  timestamp: Timestamp;
+	sequence_number: bigint;
+	entry: Uint8Array | number[];
+	anchor_number: UserNumber;
+	timestamp: Timestamp;
 }
 export interface Challenge {
-  png_base64: string;
-  challenge_key: ChallengeKey;
+	png_base64: string;
+	challenge_key: ChallengeKey;
 }
 export type ChallengeKey = string;
 export interface ChallengeResult {
-  key: ChallengeKey;
-  chars: string;
+	key: ChallengeKey;
+	chars: string;
+}
+export interface CompletedActiveAnchorStats {
+	monthly_active_anchors: [] | [ActiveAnchorCounter];
+	daily_active_anchors: [] | [ActiveAnchorCounter];
 }
 export type CredentialId = Uint8Array | number[];
 export interface Delegation {
-  pubkey: PublicKey;
-  targets: [] | [Array<Principal>];
-  expiration: Timestamp;
+	pubkey: PublicKey;
+	targets: [] | [Array<Principal>];
+	expiration: Timestamp;
 }
 export type DeployArchiveResult =
-  | {creation_in_progress: null}
-  | {success: Principal}
-  | {failed: string};
+	| { creation_in_progress: null }
+	| { success: Principal }
+	| { failed: string };
 export interface DeviceData {
-  alias: string;
-  protection: DeviceProtection;
-  pubkey: DeviceKey;
-  key_type: KeyType;
-  purpose: Purpose;
-  credential_id: [] | [CredentialId];
+	alias: string;
+	origin: [] | [string];
+	protection: DeviceProtection;
+	pubkey: DeviceKey;
+	key_type: KeyType;
+	purpose: Purpose;
+	credential_id: [] | [CredentialId];
 }
 export type DeviceKey = PublicKey;
-export type DeviceProtection = {unprotected: null} | {protected: null};
+export type DeviceProtection = { unprotected: null } | { protected: null };
 export interface DeviceRegistrationInfo {
-  tentative_device: [] | [DeviceData];
-  expiration: Timestamp;
+	tentative_device: [] | [DeviceData];
+	expiration: Timestamp;
+}
+export interface DeviceWithUsage {
+	alias: string;
+	last_usage: [] | [Timestamp];
+	origin: [] | [string];
+	protection: DeviceProtection;
+	pubkey: DeviceKey;
+	key_type: KeyType;
+	purpose: Purpose;
+	credential_id: [] | [CredentialId];
 }
 export type FrontendHostname = string;
 export type GetDelegationResponse =
-  | {no_such_delegation: null}
-  | {signed_delegation: SignedDelegation};
+	| { no_such_delegation: null }
+	| { signed_delegation: SignedDelegation };
 export type HeaderField = [string, string];
 export interface HttpRequest {
-  url: string;
-  method: string;
-  body: Uint8Array | number[];
-  headers: Array<HeaderField>;
+	url: string;
+	method: string;
+	body: Uint8Array | number[];
+	headers: Array<HeaderField>;
 }
 export interface HttpResponse {
-  body: Uint8Array | number[];
-  headers: Array<HeaderField>;
-  streaming_strategy: [] | [StreamingStrategy];
-  status_code: number;
+	body: Uint8Array | number[];
+	headers: Array<HeaderField>;
+	upgrade: [] | [boolean];
+	streaming_strategy: [] | [StreamingStrategy];
+	status_code: number;
 }
 export interface IdentityAnchorInfo {
-  devices: Array<DeviceData>;
-  device_registration: [] | [DeviceRegistrationInfo];
+	devices: Array<DeviceWithUsage>;
+	device_registration: [] | [DeviceRegistrationInfo];
 }
 export interface InternetIdentityInit {
-  upgrade_persistent_state: [] | [boolean];
-  assigned_user_number_range: [] | [[bigint, bigint]];
-  archive_config: [] | [ArchiveConfig];
-  canister_creation_cycles_cost: [] | [bigint];
+	assigned_user_number_range: [] | [[bigint, bigint]];
+	archive_config: [] | [ArchiveConfig];
+	canister_creation_cycles_cost: [] | [bigint];
+	register_rate_limit: [] | [RateLimitConfig];
 }
 export interface InternetIdentityStats {
-  storage_layout_version: number;
-  users_registered: bigint;
-  assigned_user_number_range: [bigint, bigint];
-  archive_info: ArchiveInfo;
-  canister_creation_cycles_cost: bigint;
+	storage_layout_version: number;
+	users_registered: bigint;
+	assigned_user_number_range: [bigint, bigint];
+	archive_info: ArchiveInfo;
+	canister_creation_cycles_cost: bigint;
+	active_anchor_stats: [] | [ActiveAnchorStatistics];
 }
 export type KeyType =
-  | {platform: null}
-  | {seed_phrase: null}
-  | {cross_platform: null}
-  | {unknown: null};
+	| { platform: null }
+	| { seed_phrase: null }
+	| { cross_platform: null }
+	| { unknown: null };
+export interface OngoingActiveAnchorStats {
+	monthly_active_anchors: Array<ActiveAnchorCounter>;
+	daily_active_anchors: ActiveAnchorCounter;
+}
 export type PublicKey = Uint8Array | number[];
-export type Purpose = {authentication: null} | {recovery: null};
+export type Purpose = { authentication: null } | { recovery: null };
+export interface RateLimitConfig {
+	max_tokens: bigint;
+	time_per_token_ns: bigint;
+}
 export type RegisterResponse =
-  | {bad_challenge: null}
-  | {canister_full: null}
-  | {registered: {user_number: UserNumber}};
+	| { bad_challenge: null }
+	| { canister_full: null }
+	| { registered: { user_number: UserNumber } };
 export type SessionKey = PublicKey;
 export interface SignedDelegation {
-  signature: Uint8Array | number[];
-  delegation: Delegation;
+	signature: Uint8Array | number[];
+	delegation: Delegation;
 }
 export interface StreamingCallbackHttpResponse {
-  token: [] | [Token];
-  body: Uint8Array | number[];
+	token: [] | [Token];
+	body: Uint8Array | number[];
 }
 export type StreamingStrategy = {
-  Callback: {token: Token; callback: [Principal, string]};
+	Callback: { token: Token; callback: [Principal, string] };
 };
 export type Timestamp = bigint;
 export type Token = {};
 export type UserKey = PublicKey;
 export type UserNumber = bigint;
 export type VerifyTentativeDeviceResponse =
-  | {
-      device_registration_mode_off: null;
-    }
-  | {verified: null}
-  | {wrong_code: {retries_left: number}}
-  | {no_device_to_verify: null};
+	| {
+			device_registration_mode_off: null;
+	  }
+	| { verified: null }
+	| { wrong_code: { retries_left: number } }
+	| { no_device_to_verify: null };
+export interface WebAuthnCredential {
+	pubkey: PublicKey;
+	credential_id: CredentialId;
+}
 export interface _SERVICE {
-  acknowledge_entries: ActorMethod<[bigint], undefined>;
-  add: ActorMethod<[UserNumber, DeviceData], undefined>;
-  add_tentative_device: ActorMethod<[UserNumber, DeviceData], AddTentativeDeviceResponse>;
-  create_challenge: ActorMethod<[], Challenge>;
-  deploy_archive: ActorMethod<[Uint8Array | number[]], DeployArchiveResult>;
-  enter_device_registration_mode: ActorMethod<[UserNumber], Timestamp>;
-  exit_device_registration_mode: ActorMethod<[UserNumber], undefined>;
-  fetch_entries: ActorMethod<[], Array<BufferedArchiveEntry>>;
-  get_anchor_info: ActorMethod<[UserNumber], IdentityAnchorInfo>;
-  get_delegation: ActorMethod<
-    [UserNumber, FrontendHostname, SessionKey, Timestamp],
-    GetDelegationResponse
-  >;
-  get_principal: ActorMethod<[UserNumber, FrontendHostname], Principal>;
-  http_request: ActorMethod<[HttpRequest], HttpResponse>;
-  init_salt: ActorMethod<[], undefined>;
-  lookup: ActorMethod<[UserNumber], Array<DeviceData>>;
-  prepare_delegation: ActorMethod<
-    [UserNumber, FrontendHostname, SessionKey, [] | [bigint]],
-    [UserKey, Timestamp]
-  >;
-  register: ActorMethod<[DeviceData, ChallengeResult], RegisterResponse>;
-  remove: ActorMethod<[UserNumber, DeviceKey], undefined>;
-  replace: ActorMethod<[UserNumber, DeviceKey, DeviceData], undefined>;
-  stats: ActorMethod<[], InternetIdentityStats>;
-  update: ActorMethod<[UserNumber, DeviceKey, DeviceData], undefined>;
-  verify_tentative_device: ActorMethod<[UserNumber, string], VerifyTentativeDeviceResponse>;
+	acknowledge_entries: ActorMethod<[bigint], undefined>;
+	add: ActorMethod<[UserNumber, DeviceData], undefined>;
+	add_tentative_device: ActorMethod<[UserNumber, DeviceData], AddTentativeDeviceResponse>;
+	create_challenge: ActorMethod<[], Challenge>;
+	deploy_archive: ActorMethod<[Uint8Array | number[]], DeployArchiveResult>;
+	enter_device_registration_mode: ActorMethod<[UserNumber], Timestamp>;
+	exit_device_registration_mode: ActorMethod<[UserNumber], undefined>;
+	fetch_entries: ActorMethod<[], Array<BufferedArchiveEntry>>;
+	get_anchor_credentials: ActorMethod<[UserNumber], AnchorCredentials>;
+	get_anchor_info: ActorMethod<[UserNumber], IdentityAnchorInfo>;
+	get_delegation: ActorMethod<
+		[UserNumber, FrontendHostname, SessionKey, Timestamp],
+		GetDelegationResponse
+	>;
+	get_principal: ActorMethod<[UserNumber, FrontendHostname], Principal>;
+	http_request: ActorMethod<[HttpRequest], HttpResponse>;
+	http_request_update: ActorMethod<[HttpRequest], HttpResponse>;
+	init_salt: ActorMethod<[], undefined>;
+	lookup: ActorMethod<[UserNumber], Array<DeviceData>>;
+	prepare_delegation: ActorMethod<
+		[UserNumber, FrontendHostname, SessionKey, [] | [bigint]],
+		[UserKey, Timestamp]
+	>;
+	register: ActorMethod<[DeviceData, ChallengeResult], RegisterResponse>;
+	remove: ActorMethod<[UserNumber, DeviceKey], undefined>;
+	replace: ActorMethod<[UserNumber, DeviceKey, DeviceData], undefined>;
+	stats: ActorMethod<[], InternetIdentityStats>;
+	update: ActorMethod<[UserNumber, DeviceKey, DeviceData], undefined>;
+	verify_tentative_device: ActorMethod<[UserNumber, string], VerifyTentativeDeviceResponse>;
 }