@junobuild/admin 0.0.3 → 0.0.5

package/dist/declarations/ic/ic.did

@@ -0,0 +1,82 @@
+type canister_id = principal;
+type user_id = principal;
+type wasm_module = blob;
+
+type canister_settings = record {
+  controllers : opt vec principal;
+  compute_allocation : opt nat;
+  memory_allocation : opt nat;
+  freezing_threshold : opt nat;
+};
+
+type definite_canister_settings = record {
+  controllers : vec principal;
+  compute_allocation : nat;
+  memory_allocation : nat;
+  freezing_threshold : nat;
+};
+
+type http_header = record { name: text; value: text };
+
+type http_response = record {
+  status: nat;
+  headers: vec http_header;
+  body: blob;
+};
+
+type http_request_error = variant {
+  no_consensus;
+  timeout;
+  bad_tls;
+  invalid_url;
+  transform_error;
+  dns_error;
+  unreachable;
+  conn_timeout;
+};
+
+service ic : {
+  create_canister : (record {
+    settings : opt canister_settings
+  }) -> (record {canister_id : canister_id});
+  update_settings : (record {
+    canister_id : principal;
+    settings : canister_settings
+  }) -> ();
+  install_code : (record {
+    mode : variant {install; reinstall; upgrade};
+    canister_id : canister_id;
+    wasm_module : wasm_module;
+    arg : blob;
+  }) -> ();
+  uninstall_code : (record {canister_id : canister_id}) -> ();
+  start_canister : (record {canister_id : canister_id}) -> ();
+  stop_canister : (record {canister_id : canister_id}) -> ();
+  canister_status : (record {canister_id : canister_id}) -> (record {
+      status : variant { running; stopping; stopped };
+      settings: definite_canister_settings;
+      module_hash: opt blob;
+      memory_size: nat;
+      cycles: nat;
+  });
+  delete_canister : (record {canister_id : canister_id}) -> ();
+  deposit_cycles : (record {canister_id : canister_id}) -> ();
+  raw_rand : () -> (blob);
+  http_request : (record {
+    url : text;
+    method : variant { get };
+    headers: vec http_header;
+    body : opt blob;
+    transform : opt variant {
+      function: func (http_response) -> (http_response) query
+    };
+  }) -> (variant { Ok : http_response; Err: opt http_request_error });
+
+  // provisional interfaces for the pre-ledger world
+  provisional_create_canister_with_cycles : (record {
+    amount: opt nat;
+    settings : opt canister_settings
+  }) -> (record {canister_id : canister_id});
+  provisional_top_up_canister :
+    (record { canister_id: canister_id; amount: nat }) -> ();
+}

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

@@ -0,0 +1,77 @@
+import type {Principal} from '@dfinity/principal';
+export type canister_id = Principal;
+export interface canister_settings {
+  freezing_threshold: [] | [bigint];
+  controllers: [] | [Array<Principal>];
+  memory_allocation: [] | [bigint];
+  compute_allocation: [] | [bigint];
+}
+export interface definite_canister_settings {
+  freezing_threshold: bigint;
+  controllers: Array<Principal>;
+  memory_allocation: bigint;
+  compute_allocation: bigint;
+}
+export interface http_header {
+  value: string;
+  name: string;
+}
+export type http_request_error =
+  | {dns_error: null}
+  | {no_consensus: null}
+  | {transform_error: null}
+  | {unreachable: null}
+  | {bad_tls: null}
+  | {conn_timeout: null}
+  | {invalid_url: null}
+  | {timeout: null};
+export interface http_response {
+  status: bigint;
+  body: Array<number>;
+  headers: Array<http_header>;
+}
+export type user_id = Principal;
+export type wasm_module = Array<number>;
+export interface _SERVICE {
+  canister_status: (arg_0: {canister_id: canister_id}) => Promise<{
+    status: {stopped: null} | {stopping: null} | {running: null};
+    memory_size: bigint;
+    cycles: bigint;
+    settings: definite_canister_settings;
+    module_hash: [] | [Array<number>];
+  }>;
+  create_canister: (arg_0: {
+    settings: [] | [canister_settings];
+  }) => Promise<{canister_id: canister_id}>;
+  delete_canister: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  deposit_cycles: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  http_request: (arg_0: {
+    url: string;
+    method: {get: null};
+    body: [] | [Array<number>];
+    transform: [] | [{function: [Principal, string]}];
+    headers: Array<http_header>;
+  }) => Promise<{Ok: http_response} | {Err: [] | [http_request_error]}>;
+  install_code: (arg_0: {
+    arg: Array<number>;
+    wasm_module: wasm_module;
+    mode: {reinstall: null} | {upgrade: null} | {install: null};
+    canister_id: canister_id;
+  }) => Promise<undefined>;
+  provisional_create_canister_with_cycles: (arg_0: {
+    settings: [] | [canister_settings];
+    amount: [] | [bigint];
+  }) => Promise<{canister_id: canister_id}>;
+  provisional_top_up_canister: (arg_0: {
+    canister_id: canister_id;
+    amount: bigint;
+  }) => Promise<undefined>;
+  raw_rand: () => Promise<Array<number>>;
+  start_canister: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  stop_canister: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  uninstall_code: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  update_settings: (arg_0: {
+    canister_id: Principal;
+    settings: canister_settings;
+  }) => Promise<undefined>;
+}

package/dist/declarations/ic/ic.factory.did.js

@@ -0,0 +1,128 @@
+export const idlFactory = ({IDL}) => {
+  const canister_id = IDL.Principal;
+  const definite_canister_settings = IDL.Record({
+    freezing_threshold: IDL.Nat,
+    controllers: IDL.Vec(IDL.Principal),
+    memory_allocation: IDL.Nat,
+    compute_allocation: IDL.Nat
+  });
+  const canister_settings = IDL.Record({
+    freezing_threshold: IDL.Opt(IDL.Nat),
+    controllers: IDL.Opt(IDL.Vec(IDL.Principal)),
+    memory_allocation: IDL.Opt(IDL.Nat),
+    compute_allocation: IDL.Opt(IDL.Nat)
+  });
+  const http_header = IDL.Record({value: IDL.Text, name: IDL.Text});
+  const http_response = IDL.Record({
+    status: IDL.Nat,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(http_header)
+  });
+  const http_request_error = IDL.Variant({
+    dns_error: IDL.Null,
+    no_consensus: IDL.Null,
+    transform_error: IDL.Null,
+    unreachable: IDL.Null,
+    bad_tls: IDL.Null,
+    conn_timeout: IDL.Null,
+    invalid_url: IDL.Null,
+    timeout: IDL.Null
+  });
+  const wasm_module = IDL.Vec(IDL.Nat8);
+  return IDL.Service({
+    canister_status: IDL.Func(
+      [IDL.Record({canister_id: canister_id})],
+      [
+        IDL.Record({
+          status: IDL.Variant({
+            stopped: IDL.Null,
+            stopping: IDL.Null,
+            running: IDL.Null
+          }),
+          memory_size: IDL.Nat,
+          cycles: IDL.Nat,
+          settings: definite_canister_settings,
+          module_hash: IDL.Opt(IDL.Vec(IDL.Nat8))
+        })
+      ],
+      []
+    ),
+    create_canister: IDL.Func(
+      [IDL.Record({settings: IDL.Opt(canister_settings)})],
+      [IDL.Record({canister_id: canister_id})],
+      []
+    ),
+    delete_canister: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    deposit_cycles: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    http_request: IDL.Func(
+      [
+        IDL.Record({
+          url: IDL.Text,
+          method: IDL.Variant({get: IDL.Null}),
+          body: IDL.Opt(IDL.Vec(IDL.Nat8)),
+          transform: IDL.Opt(
+            IDL.Variant({
+              function: IDL.Func([http_response], [http_response], ['query'])
+            })
+          ),
+          headers: IDL.Vec(http_header)
+        })
+      ],
+      [
+        IDL.Variant({
+          Ok: http_response,
+          Err: IDL.Opt(http_request_error)
+        })
+      ],
+      []
+    ),
+    install_code: IDL.Func(
+      [
+        IDL.Record({
+          arg: IDL.Vec(IDL.Nat8),
+          wasm_module: wasm_module,
+          mode: IDL.Variant({
+            reinstall: IDL.Null,
+            upgrade: IDL.Null,
+            install: IDL.Null
+          }),
+          canister_id: canister_id
+        })
+      ],
+      [],
+      []
+    ),
+    provisional_create_canister_with_cycles: IDL.Func(
+      [
+        IDL.Record({
+          settings: IDL.Opt(canister_settings),
+          amount: IDL.Opt(IDL.Nat)
+        })
+      ],
+      [IDL.Record({canister_id: canister_id})],
+      []
+    ),
+    provisional_top_up_canister: IDL.Func(
+      [IDL.Record({canister_id: canister_id, amount: IDL.Nat})],
+      [],
+      []
+    ),
+    raw_rand: IDL.Func([], [IDL.Vec(IDL.Nat8)], []),
+    start_canister: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    stop_canister: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    uninstall_code: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    update_settings: IDL.Func(
+      [
+        IDL.Record({
+          canister_id: IDL.Principal,
+          settings: canister_settings
+        })
+      ],
+      [],
+      []
+    )
+  });
+};
+export const init = ({IDL}) => {
+  return [];
+};

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

@@ -0,0 +1,45 @@
+import type {ActorConfig, ActorSubclass, Agent, HttpAgentOptions} from '@dfinity/agent';
+import type {IDL} from '@dfinity/candid';
+import type {Principal} from '@dfinity/principal';
+
+import {_SERVICE} from './internet_identity.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const internet_identity: ActorSubclass<_SERVICE>;

package/dist/declarations/internet_identity/index.js

@@ -0,0 +1,32 @@
+import {Actor, HttpAgent} from '@dfinity/agent';
+
+// Imports and re-exports candid interface
+import {idlFactory} from './internet_identity.did.js';
+export {idlFactory} from './internet_identity.did.js';
+
+// CANISTER_ID is replaced by webpack based on node environment
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({...options.agentOptions});
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      'Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent.'
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== 'ic') {
+    agent.fetchRootKey().catch((err) => {
+      console.warn('Unable to fetch root key. Check to ensure that your local replica is running');
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions
+  });
+};

package/dist/declarations/internet_identity/internet_identity.did

@@ -0,0 +1,271 @@
+type UserNumber = nat64;
+type PublicKey = blob;
+type CredentialId = blob;
+type DeviceKey = PublicKey;
+type UserKey = PublicKey;
+type SessionKey = PublicKey;
+type FrontendHostname = text;
+type Timestamp = nat64;
+
+type HeaderField = record {
+    text;
+    text;
+};
+
+type HttpRequest = record {
+    method: text;
+    url: text;
+    headers: vec HeaderField;
+    body: blob;
+};
+
+type HttpResponse = record {
+    status_code: nat16;
+    headers: vec HeaderField;
+    body: blob;
+    streaming_strategy: opt StreamingStrategy;
+};
+
+type StreamingCallbackHttpResponse = record {
+    body: blob;
+    token: opt Token;
+};
+
+type Token = record {};
+
+type StreamingStrategy = variant {
+    Callback: record {
+        callback: func (Token) -> (StreamingCallbackHttpResponse) query;
+        token: Token;
+    };
+};
+
+type Purpose = variant {
+    recovery;
+    authentication;
+};
+
+type KeyType = variant {
+    unknown;
+    platform;
+    cross_platform;
+    seed_phrase;
+};
+
+// This describes whether a device is "protected" or not.
+// When protected, a device can only be updated or removed if the
+// user is authenticated with that very device.
+type DeviceProtection = variant {
+    protected;
+    unprotected;
+};
+
+type Challenge = record {
+    png_base64: text;
+    challenge_key: ChallengeKey;
+};
+
+type DeviceData = record {
+    pubkey : DeviceKey;
+    alias : text;
+    credential_id : opt CredentialId;
+    purpose: Purpose;
+    key_type: KeyType;
+    protection: DeviceProtection;
+};
+
+type RegisterResponse = variant {
+    // A new user was successfully registered.
+    registered: record {
+        user_number: UserNumber;
+    };
+    // No more registrations are possible in this instance of the II service canister.
+    canister_full;
+    // The challenge was not successful.
+    bad_challenge;
+};
+
+type AddTentativeDeviceResponse = variant {
+    // The device was tentatively added.
+    added_tentatively: record {
+        verification_code: text;
+        device_registration_timeout: Timestamp;
+    };
+    // Device registration mode is off, either due to timeout or because it was never enabled.
+    device_registration_mode_off;
+    // There is another device already added tentatively
+    another_device_tentatively_added;
+};
+
+type VerifyTentativeDeviceResponse = variant {
+    // The device was successfully verified.
+    verified;
+    // Wrong verification code entered. Retry with correct code.
+    wrong_code: record {
+        retries_left: nat8
+    };
+    // Device registration mode is off, either due to timeout or because it was never enabled.
+    device_registration_mode_off;
+    // There is no tentative device to be verified.
+    no_device_to_verify;
+};
+
+type Delegation = record {
+    pubkey: PublicKey;
+    expiration: Timestamp;
+    targets: opt vec principal;
+};
+
+type SignedDelegation = record {
+    delegation: Delegation;
+    signature: blob;
+};
+
+type GetDelegationResponse = variant {
+    // The signed delegation was successfully retrieved.
+    signed_delegation: SignedDelegation;
+
+    // The signature is not ready. Maybe retry by calling `prepare_delegation`
+    no_such_delegation
+};
+
+type InternetIdentityStats = record {
+    users_registered: nat64;
+    storage_layout_version: nat8;
+    assigned_user_number_range: record {
+        nat64;
+        nat64;
+    };
+    archive_info: ArchiveInfo;
+    canister_creation_cycles_cost: nat64;
+};
+
+// Configuration parameters related to the archive.
+type ArchiveConfig = record {
+    // The allowed module hash of the archive canister.
+    // Changing this parameter does _not_ deploy the archive, but enable archive deployments with the
+    // corresponding wasm module.
+    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.
+type ArchiveInfo = record {
+    // Canister id of the archive or empty if no archive has been deployed yet.
+    archive_canister : opt principal;
+    // Configuration parameters related to the II archive.
+    archive_config: opt ArchiveConfig;
+};
+
+// Init arguments of II which can be supplied on install and upgrade.
+// Setting a value to null keeps the previous value.
+type InternetIdentityInit = record {
+    // Set lowest and highest anchor
+    assigned_user_number_range : opt record {
+        nat64;
+        nat64;
+    };
+    // Configuration parameters related to the II archive.
+    // Note: some parameters changes (like the polling interval) will only take effect after an archive deployment.
+    // See ArchiveConfig for details.
+    archive_config: opt ArchiveConfig;
+    // Set the amounts of cycles sent with the create canister message.
+    // This is configurable because in the staging environment cycles are required.
+    // 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;
+};
+
+type ChallengeKey = text;
+
+type ChallengeResult = record {
+    key : ChallengeKey;
+    chars : text;
+};
+
+type DeviceRegistrationInfo = record {
+    tentative_device : opt DeviceData;
+    expiration: Timestamp;
+};
+
+type IdentityAnchorInfo = record {
+    devices : vec DeviceData;
+    device_registration: opt DeviceRegistrationInfo;
+};
+
+type DeployArchiveResult = variant {
+    // The archive was deployed successfully and the supplied wasm module has been installed. The principal of the archive
+    // canister is returned.
+    success: principal;
+    // Initial archive creation is already in progress.
+    creation_in_progress;
+    // Archive deployment failed. An error description is returned.
+    failed: text;
+};
+
+type BufferedArchiveEntry = record {
+    anchor_number: UserNumber;
+    timestamp: Timestamp;
+    sequence_number: nat64;
+    entry: blob;
+};
+
+
+service : (opt InternetIdentityInit) -> {
+    init_salt: () -> ();
+    create_challenge : () -> (Challenge);
+    register : (DeviceData, ChallengeResult) -> (RegisterResponse);
+    add : (UserNumber, DeviceData) -> ();
+    update : (UserNumber, DeviceKey, DeviceData) -> ();
+    // Atomically replace device matching the device key with the new device data
+    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.
+    lookup : (UserNumber) -> (vec DeviceData) query;
+    get_anchor_info : (UserNumber) -> (IdentityAnchorInfo);
+    get_principal : (UserNumber, FrontendHostname) -> (principal) query;
+    stats : () -> (InternetIdentityStats) query;
+
+    enter_device_registration_mode : (UserNumber) -> (Timestamp);
+    exit_device_registration_mode : (UserNumber) -> ();
+    add_tentative_device : (UserNumber, DeviceData) -> (AddTentativeDeviceResponse);
+    verify_tentative_device : (UserNumber, verification_code: text) -> (VerifyTentativeDeviceResponse);
+
+    prepare_delegation : (UserNumber, FrontendHostname, SessionKey, maxTimeToLive : opt nat64) -> (UserKey, Timestamp);
+    get_delegation: (UserNumber, FrontendHostname, SessionKey, Timestamp) -> (GetDelegationResponse) query;
+
+    http_request: (request: HttpRequest) -> (HttpResponse) query;
+
+    deploy_archive: (wasm: blob) -> (DeployArchiveResult);
+    /// Returns a batch of entries _sorted by sequence number_ to be archived.
+    /// This is an update call because the archive information _must_ be certified.
+    /// Only callable by this IIs archive canister.
+    fetch_entries: () -> (vec BufferedArchiveEntry);
+    acknowledge_entries: (sequence_number: nat64) -> ();
+}