backend.did

type AddUserCredentialError = variant {
  InvalidCredential;
  VersionMismatch;
  ConfigurationError;
  UserNotFound;
};
type AddUserCredentialRequest = record {
  credential_jwt : text;
  issuer_canister_id : principal;
  current_user_version : opt nat64;
  credential_spec : CredentialSpec;
};
type AllowSigningError = variant {
  ApproveError : ApproveError;
  Other : text;
  FailedToContactCyclesLedger;
};
type ApiEnabled = variant { ReadOnly; Enabled; Disabled };
type ApproveError = variant {
  GenericError : record { message : text; error_code : nat };
  TemporarilyUnavailable;
  Duplicate : record { duplicate_of : nat };
  BadFee : record { expected_fee : nat };
  AllowanceChanged : record { current_allowance : nat };
  CreatedInFuture : record { ledger_time : nat64 };
  TooOld;
  Expired : record { ledger_time : nat64 };
  InsufficientFunds : record { balance : nat };
};
type Arg = variant { Upgrade; Init : InitArg };
type ArgumentValue = variant { Int : int32; String : text };
type BitcoinNetwork = variant { mainnet; regtest; testnet };
type BtcAddPendingTransactionError = variant {
  InternalError : record { msg : text };
};
type BtcAddPendingTransactionRequest = record {
  txid : blob;
  network : BitcoinNetwork;
  address : text;
  utxos : vec Utxo;
};
type BtcGetPendingTransactionsReponse = record {
  transactions : vec PendingTransaction;
};
type BtcGetPendingTransactionsRequest = record {
  network : BitcoinNetwork;
  address : text;
};
type CanisterStatusResultV2 = record {
  controller : principal;
  status : CanisterStatusType;
  freezing_threshold : nat;
  balance : vec record { blob; nat };
  memory_size : nat;
  cycles : nat;
  settings : DefiniteCanisterSettingsArgs;
  idle_cycles_burned_per_day : nat;
  module_hash : opt blob;
};
type CanisterStatusType = variant { stopped; stopping; running };
type Config = record {
  api : opt Guards;
  derivation_origin : opt text;
  ecdsa_key_name : text;
  cfs_canister_id : opt principal;
  allowed_callers : vec principal;
  supported_credentials : opt vec SupportedCredential;
  ic_root_key_raw : opt blob;
};
type CredentialSpec = record {
  arguments : opt vec record { text; ArgumentValue };
  credential_type : text;
};
type CredentialType = variant { ProofOfUniqueness };
type CustomToken = record {
  token : Token;
  version : opt nat64;
  enabled : bool;
};
type DefiniteCanisterSettingsArgs = record {
  controller : principal;
  freezing_threshold : nat;
  controllers : vec principal;
  memory_allocation : nat;
  compute_allocation : nat;
};
type GetUserProfileError = variant { NotFound };
type Guards = record { user_data : ApiEnabled; threshold_key : ApiEnabled };
type HttpRequest = record {
  url : text;
  method : text;
  body : blob;
  headers : vec record { text; text };
};
type HttpResponse = record {
  body : blob;
  headers : vec record { text; text };
  status_code : nat16;
};
type IcrcToken = record { ledger_id : principal; index_id : opt principal };
type InitArg = record {
  api : opt Guards;
  derivation_origin : opt text;
  ecdsa_key_name : text;
  cfs_canister_id : opt principal;
  allowed_callers : vec principal;
  supported_credentials : opt vec SupportedCredential;
  ic_root_key_der : opt blob;
};
type ListUsersRequest = record {
  updated_after_timestamp : opt nat64;
  matches_max_length : opt nat64;
};
type ListUsersResponse = record {
  users : vec OisyUser;
  matches_max_length : nat64;
};
type MigrationError = variant {
  TargetLockFailed;
  TargetUnlockFailed;
  CouldNotGetTargetPostStats;
  CouldNotGetTargetPriorStats;
  DataMigrationFailed;
  TargetStatsMismatch : record { Stats; Stats };
  Unknown;
  TargetCanisterNotEmpty : Stats;
  NoMigrationInProgress;
};
type MigrationProgress = variant {
  MigratedUserTokensUpTo : opt principal;
  Failed : MigrationError;
  MigratedUserTimestampsUpTo : opt principal;
  MigratedCustomTokensUpTo : opt principal;
  CheckingDataMigration;
  MigratedUserProfilesUpTo : opt record { nat64; principal };
  UnlockingTarget;
  Unlocking;
  Completed;
  Pending;
  LockingTarget;
  CheckingTarget;
};
type MigrationReport = record { to : principal; progress : MigrationProgress };
type OisyUser = record {
  "principal" : principal;
  pouh_verified : bool;
  updated_timestamp : nat64;
};
type Outpoint = record { txid : blob; vout : nat32 };
type PendingTransaction = record { txid : blob; utxos : vec Utxo };
type Result = variant { Ok; Err : AddUserCredentialError };
type Result_1 = variant { Ok; Err : AllowSigningError };
type Result_2 = variant { Ok; Err : BtcAddPendingTransactionError };
type Result_3 = variant {
  Ok : BtcGetPendingTransactionsReponse;
  Err : BtcAddPendingTransactionError;
};
type Result_4 = variant {
  Ok : SelectedUtxosFeeResponse;
  Err : SelectedUtxosFeeError;
};
type Result_5 = variant { Ok : UserProfile; Err : GetUserProfileError };
type Result_6 = variant { Ok : MigrationReport; Err : text };
type Result_7 = variant { Ok; Err : text };
type Result_8 = variant {
  Ok : TopUpCyclesLedgerResponse;
  Err : TopUpCyclesLedgerError;
};
type SelectedUtxosFeeError = variant {
  PendingTransactions;
  InternalError : record { msg : text };
};
type SelectedUtxosFeeRequest = record {
  network : BitcoinNetwork;
  amount_satoshis : nat64;
  min_confirmations : opt nat32;
};
type SelectedUtxosFeeResponse = record {
  fee_satoshis : nat64;
  utxos : vec Utxo;
};
type Stats = record {
  user_profile_count : nat64;
  custom_token_count : nat64;
  user_timestamps_count : nat64;
  user_token_count : nat64;
};
type SupportedCredential = record {
  ii_canister_id : principal;
  issuer_origin : text;
  issuer_canister_id : principal;
  ii_origin : text;
  credential_type : CredentialType;
};
type Token = variant { Icrc : IcrcToken };
type TopUpCyclesLedgerError = variant {
  InvalidArgPercentageOutOfRange : record {
    max : nat8;
    min : nat8;
    percentage : nat8;
  };
  CouldNotGetBalanceFromCyclesLedger;
  CouldNotTopUpCyclesLedger : record { tried_to_send : nat; available : nat };
};
type TopUpCyclesLedgerRequest = record {
  threshold : opt nat;
  percentage : opt nat8;
};
type TopUpCyclesLedgerResponse = record {
  backend_cycles : nat;
  ledger_balance : nat;
  topped_up : nat;
};
type UserCredential = record {
  issuer : text;
  verified_date_timestamp : opt nat64;
  credential_type : CredentialType;
};
type UserProfile = record {
  credentials : vec UserCredential;
  version : opt nat64;
  created_timestamp : nat64;
  updated_timestamp : nat64;
};
type UserToken = record {
  decimals : opt nat8;
  version : opt nat64;
  enabled : opt bool;
  chain_id : nat64;
  contract_address : text;
  symbol : opt text;
};
type UserTokenId = record { chain_id : nat64; contract_address : text };
type Utxo = record { height : nat32; value : nat64; outpoint : Outpoint };
service : (Arg) -> {
  add_user_credential : (AddUserCredentialRequest) -> (Result);
  allow_signing : () -> (Result_1);
  btc_add_pending_transaction : (BtcAddPendingTransactionRequest) -> (Result_2);
  btc_get_pending_transactions : (BtcGetPendingTransactionsRequest) -> (
      Result_3,
    );
  btc_select_user_utxos_fee : (SelectedUtxosFeeRequest) -> (Result_4);
  bulk_up : (blob) -> ();
  config : () -> (Config) query;
  create_user_profile : () -> (UserProfile);
  get_canister_status : () -> (CanisterStatusResultV2);
  get_user_profile : () -> (Result_5) query;
  http_request : (HttpRequest) -> (HttpResponse) query;
  list_custom_tokens : () -> (vec CustomToken) query;
  list_user_tokens : () -> (vec UserToken) query;
  list_users : (ListUsersRequest) -> (ListUsersResponse) query;
  migrate_user_data_to : (principal) -> (Result_6);
  migration : () -> (opt MigrationReport) query;
  migration_stop_timer : () -> (Result_7);
  remove_user_token : (UserTokenId) -> ();
  set_custom_token : (CustomToken) -> ();
  set_guards : (Guards) -> ();
  set_many_custom_tokens : (vec CustomToken) -> ();
  set_many_user_tokens : (vec UserToken) -> ();
  set_user_token : (UserToken) -> ();
  stats : () -> (Stats) query;
  step_migration : () -> ();
  top_up_cycles_ledger : (opt TopUpCyclesLedgerRequest) -> (Result_8);
}