@junobuild/admin 0.0.3 → 0.0.4

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) -> ();
+}

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

@@ -0,0 +1,161 @@
+import type {ActorMethod} from '@dfinity/agent';
+import type {Principal} from '@dfinity/principal';
+
+export type AddTentativeDeviceResponse =
+  | {
+      device_registration_mode_off: null;
+    }
+  | {another_device_tentatively_added: null}
+  | {
+      added_tentatively: {
+        verification_code: string;
+        device_registration_timeout: Timestamp;
+      };
+    };
+export interface ArchiveConfig {
+  polling_interval_ns: bigint;
+  entries_buffer_limit: bigint;
+  archive_integration: [] | [{pull: null} | {push: null}];
+  module_hash: Uint8Array;
+  entries_fetch_limit: number;
+}
+export interface ArchiveInfo {
+  archive_config: [] | [ArchiveConfig];
+  archive_canister: [] | [Principal];
+}
+export interface BufferedArchiveEntry {
+  sequence_number: bigint;
+  entry: Uint8Array;
+  anchor_number: UserNumber;
+  timestamp: Timestamp;
+}
+export interface Challenge {
+  png_base64: string;
+  challenge_key: ChallengeKey;
+}
+export type ChallengeKey = string;
+export interface ChallengeResult {
+  key: ChallengeKey;
+  chars: string;
+}
+export type CredentialId = Uint8Array;
+export interface Delegation {
+  pubkey: PublicKey;
+  targets: [] | [Array<Principal>];
+  expiration: Timestamp;
+}
+export type DeployArchiveResult =
+  | {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];
+}
+export type DeviceKey = PublicKey;
+export type DeviceProtection = {unprotected: null} | {protected: null};
+export interface DeviceRegistrationInfo {
+  tentative_device: [] | [DeviceData];
+  expiration: Timestamp;
+}
+export type FrontendHostname = string;
+export type GetDelegationResponse =
+  | {no_such_delegation: null}
+  | {signed_delegation: SignedDelegation};
+export type HeaderField = [string, string];
+export interface HttpRequest {
+  url: string;
+  method: string;
+  body: Uint8Array;
+  headers: Array<HeaderField>;
+}
+export interface HttpResponse {
+  body: Uint8Array;
+  headers: Array<HeaderField>;
+  streaming_strategy: [] | [StreamingStrategy];
+  status_code: number;
+}
+export interface IdentityAnchorInfo {
+  devices: Array<DeviceData>;
+  device_registration: [] | [DeviceRegistrationInfo];
+}
+export interface InternetIdentityInit {
+  upgrade_persistent_state: [] | [boolean];
+  assigned_user_number_range: [] | [[bigint, bigint]];
+  archive_config: [] | [ArchiveConfig];
+  canister_creation_cycles_cost: [] | [bigint];
+}
+export interface InternetIdentityStats {
+  storage_layout_version: number;
+  users_registered: bigint;
+  assigned_user_number_range: [bigint, bigint];
+  archive_info: ArchiveInfo;
+  canister_creation_cycles_cost: bigint;
+}
+export type KeyType =
+  | {platform: null}
+  | {seed_phrase: null}
+  | {cross_platform: null}
+  | {unknown: null};
+export type PublicKey = Uint8Array;
+export type Purpose = {authentication: null} | {recovery: null};
+export type RegisterResponse =
+  | {bad_challenge: null}
+  | {canister_full: null}
+  | {registered: {user_number: UserNumber}};
+export type SessionKey = PublicKey;
+export interface SignedDelegation {
+  signature: Uint8Array;
+  delegation: Delegation;
+}
+export interface StreamingCallbackHttpResponse {
+  token: [] | [Token];
+  body: Uint8Array;
+}
+export type StreamingStrategy = {
+  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};
+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], 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>;
+}

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

@@ -0,0 +1,187 @@
+export const idlFactory = ({IDL}) => {
+  const ArchiveConfig = IDL.Record({
+    polling_interval_ns: IDL.Nat64,
+    entries_buffer_limit: IDL.Nat64,
+    archive_integration: IDL.Opt(IDL.Variant({pull: IDL.Null, push: IDL.Null})),
+    module_hash: IDL.Vec(IDL.Nat8),
+    entries_fetch_limit: IDL.Nat16
+  });
+  const InternetIdentityInit = IDL.Record({
+    upgrade_persistent_state: IDL.Opt(IDL.Bool),
+    assigned_user_number_range: IDL.Opt(IDL.Tuple(IDL.Nat64, IDL.Nat64)),
+    archive_config: IDL.Opt(ArchiveConfig),
+    canister_creation_cycles_cost: IDL.Opt(IDL.Nat64)
+  });
+  const UserNumber = IDL.Nat64;
+  const DeviceProtection = IDL.Variant({
+    unprotected: IDL.Null,
+    protected: IDL.Null
+  });
+  const PublicKey = IDL.Vec(IDL.Nat8);
+  const DeviceKey = PublicKey;
+  const KeyType = IDL.Variant({
+    platform: IDL.Null,
+    seed_phrase: IDL.Null,
+    cross_platform: IDL.Null,
+    unknown: IDL.Null
+  });
+  const Purpose = IDL.Variant({
+    authentication: IDL.Null,
+    recovery: IDL.Null
+  });
+  const CredentialId = IDL.Vec(IDL.Nat8);
+  const DeviceData = IDL.Record({
+    alias: IDL.Text,
+    protection: DeviceProtection,
+    pubkey: DeviceKey,
+    key_type: KeyType,
+    purpose: Purpose,
+    credential_id: IDL.Opt(CredentialId)
+  });
+  const Timestamp = IDL.Nat64;
+  const AddTentativeDeviceResponse = IDL.Variant({
+    device_registration_mode_off: IDL.Null,
+    another_device_tentatively_added: IDL.Null,
+    added_tentatively: IDL.Record({
+      verification_code: IDL.Text,
+      device_registration_timeout: Timestamp
+    })
+  });
+  const ChallengeKey = IDL.Text;
+  const Challenge = IDL.Record({
+    png_base64: IDL.Text,
+    challenge_key: ChallengeKey
+  });
+  const DeployArchiveResult = IDL.Variant({
+    creation_in_progress: IDL.Null,
+    success: IDL.Principal,
+    failed: IDL.Text
+  });
+  const BufferedArchiveEntry = IDL.Record({
+    sequence_number: IDL.Nat64,
+    entry: IDL.Vec(IDL.Nat8),
+    anchor_number: UserNumber,
+    timestamp: Timestamp
+  });
+  const DeviceRegistrationInfo = IDL.Record({
+    tentative_device: IDL.Opt(DeviceData),
+    expiration: Timestamp
+  });
+  const IdentityAnchorInfo = IDL.Record({
+    devices: IDL.Vec(DeviceData),
+    device_registration: IDL.Opt(DeviceRegistrationInfo)
+  });
+  const FrontendHostname = IDL.Text;
+  const SessionKey = PublicKey;
+  const Delegation = IDL.Record({
+    pubkey: PublicKey,
+    targets: IDL.Opt(IDL.Vec(IDL.Principal)),
+    expiration: Timestamp
+  });
+  const SignedDelegation = IDL.Record({
+    signature: IDL.Vec(IDL.Nat8),
+    delegation: Delegation
+  });
+  const GetDelegationResponse = IDL.Variant({
+    no_such_delegation: IDL.Null,
+    signed_delegation: SignedDelegation
+  });
+  const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+  const HttpRequest = IDL.Record({
+    url: IDL.Text,
+    method: IDL.Text,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField)
+  });
+  const Token = IDL.Record({});
+  const StreamingCallbackHttpResponse = IDL.Record({
+    token: IDL.Opt(Token),
+    body: IDL.Vec(IDL.Nat8)
+  });
+  const StreamingStrategy = IDL.Variant({
+    Callback: IDL.Record({
+      token: Token,
+      callback: IDL.Func([Token], [StreamingCallbackHttpResponse], ['query'])
+    })
+  });
+  const HttpResponse = IDL.Record({
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField),
+    streaming_strategy: IDL.Opt(StreamingStrategy),
+    status_code: IDL.Nat16
+  });
+  const UserKey = PublicKey;
+  const ChallengeResult = IDL.Record({
+    key: ChallengeKey,
+    chars: IDL.Text
+  });
+  const RegisterResponse = IDL.Variant({
+    bad_challenge: IDL.Null,
+    canister_full: IDL.Null,
+    registered: IDL.Record({user_number: UserNumber})
+  });
+  const ArchiveInfo = IDL.Record({
+    archive_config: IDL.Opt(ArchiveConfig),
+    archive_canister: IDL.Opt(IDL.Principal)
+  });
+  const InternetIdentityStats = IDL.Record({
+    storage_layout_version: IDL.Nat8,
+    users_registered: IDL.Nat64,
+    assigned_user_number_range: IDL.Tuple(IDL.Nat64, IDL.Nat64),
+    archive_info: ArchiveInfo,
+    canister_creation_cycles_cost: IDL.Nat64
+  });
+  const VerifyTentativeDeviceResponse = IDL.Variant({
+    device_registration_mode_off: IDL.Null,
+    verified: IDL.Null,
+    wrong_code: IDL.Record({retries_left: IDL.Nat8}),
+    no_device_to_verify: IDL.Null
+  });
+  return IDL.Service({
+    acknowledge_entries: IDL.Func([IDL.Nat64], [], []),
+    add: IDL.Func([UserNumber, DeviceData], [], []),
+    add_tentative_device: IDL.Func([UserNumber, DeviceData], [AddTentativeDeviceResponse], []),
+    create_challenge: IDL.Func([], [Challenge], []),
+    deploy_archive: IDL.Func([IDL.Vec(IDL.Nat8)], [DeployArchiveResult], []),
+    enter_device_registration_mode: IDL.Func([UserNumber], [Timestamp], []),
+    exit_device_registration_mode: IDL.Func([UserNumber], [], []),
+    fetch_entries: IDL.Func([], [IDL.Vec(BufferedArchiveEntry)], []),
+    get_anchor_info: IDL.Func([UserNumber], [IdentityAnchorInfo], []),
+    get_delegation: IDL.Func(
+      [UserNumber, FrontendHostname, SessionKey, Timestamp],
+      [GetDelegationResponse],
+      ['query']
+    ),
+    get_principal: IDL.Func([UserNumber, FrontendHostname], [IDL.Principal], ['query']),
+    http_request: IDL.Func([HttpRequest], [HttpResponse], ['query']),
+    init_salt: IDL.Func([], [], []),
+    lookup: IDL.Func([UserNumber], [IDL.Vec(DeviceData)], ['query']),
+    prepare_delegation: IDL.Func(
+      [UserNumber, FrontendHostname, SessionKey, IDL.Opt(IDL.Nat64)],
+      [UserKey, Timestamp],
+      []
+    ),
+    register: IDL.Func([DeviceData, ChallengeResult], [RegisterResponse], []),
+    remove: IDL.Func([UserNumber, DeviceKey], [], []),
+    replace: IDL.Func([UserNumber, DeviceKey, DeviceData], [], []),
+    stats: IDL.Func([], [InternetIdentityStats], ['query']),
+    update: IDL.Func([UserNumber, DeviceKey, DeviceData], [], []),
+    verify_tentative_device: IDL.Func([UserNumber, IDL.Text], [VerifyTentativeDeviceResponse], [])
+  });
+};
+export const init = ({IDL}) => {
+  const ArchiveConfig = IDL.Record({
+    polling_interval_ns: IDL.Nat64,
+    entries_buffer_limit: IDL.Nat64,
+    archive_integration: IDL.Opt(IDL.Variant({pull: IDL.Null, push: IDL.Null})),
+    module_hash: IDL.Vec(IDL.Nat8),
+    entries_fetch_limit: IDL.Nat16
+  });
+  const InternetIdentityInit = IDL.Record({
+    upgrade_persistent_state: IDL.Opt(IDL.Bool),
+    assigned_user_number_range: IDL.Opt(IDL.Tuple(IDL.Nat64, IDL.Nat64)),
+    archive_config: IDL.Opt(ArchiveConfig),
+    canister_creation_cycles_cost: IDL.Opt(IDL.Nat64)
+  });
+  return [IDL.Opt(InternetIdentityInit)];
+};

package/dist/declarations/ledger/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 './ledger.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 ledger: ActorSubclass<_SERVICE>;