import 'dart:typed_data';

import 'package:affinidi_tdk_vault/affinidi_tdk_vault.dart';
import 'package:affinidi_tdk_vault_data_manager/affinidi_tdk_vault_data_manager.dart';

void main() async {
  // Initialise InMemory storage
  final accountIndex = 32;
  final vaultStore = InMemoryVaultStore();
  await vaultStore.writeAccountIndex(accountIndex);

  // Generate seed from the storage layer
  final seed = vaultStore.getRandomSeed();
  await vaultStore.setSeed(seed);

  // Initialise profile interface
  const vfsRepositoryId = 'vfs';
  final profileRepositories = <String, ProfileRepository>{
    vfsRepositoryId: VfsProfileRepository(vfsRepositoryId),
  };

  // In this example, we are using Bip32 type wallet from SSI package
  final vault = await Vault.fromVaultStore(
    vaultStore,
    profileRepositories: profileRepositories,
    defaultProfileRepositoryId: vfsRepositoryId,
  );

  // Ensure vault is initialised before being able to access any of the repositories
  await vault.ensureInitialized();
}

import 'package:built_collection/built_collection.dart';
import 'package:dio/dio.dart';
import 'package:affinidi_tdk_auth_provider/affinidi_tdk_auth_provider.dart';
import 'package:affinidi_tdk_credential_issuance_client/affinidi_tdk_credential_issuance_client.dart';
import 'package:built_value/json_object.dart';


try {

  // NOTE: Set your variables for PAT
  final privateKey = '<PAT_PRIVATE_KEY_STRING>';
  final passphrase = '<PAT_KEY_PAIR_PASSPHRASE>';
  final tokenId = '<PAT_ID>';
  final projectId = '<PROJECT_ID>';

  final authProvider = AuthProvider(
    privateKey: privateKey,
    passphrase: passphrase,
    tokenId: tokenId,
    projectId: projectId,
  );


  late IssuanceApi issuanceApi;

  final issuanceClient = AffinidiTdkCredentialIssuanceClient(
    dio: Dio(BaseOptions(
      baseUrl: AffinidiTdkCredentialIssuanceClient.basePath,
      connectTimeout: const Duration(seconds: 10),
      receiveTimeout: const Duration(seconds: 10),
    )),
    authTokenHook: authProvider.fetchProjectScopedToken,
  );

  issuanceApi = issuanceClient.getIssuanceApi();

  final credentialTypeId = 'SchemaOne';

  final credentialData = {
    'first_name': 'FirstName',
    'last_name': 'LastName',
    'dob': '1970-01-01',
  };

  final credentialDataBuilder = MapBuilder<String, JsonObject>(
    credentialData.map((key, value) => MapEntry(key, JsonObject(value))),
  );


  final data = StartIssuanceInputDataInnerBuilder()
    ..credentialTypeId = credentialTypeId
    ..credentialData.replace(credentialDataBuilder.build());

  final startIssuanceInput = StartIssuanceInputBuilder()
    ..holderDid = 'did:key:holder-did-value'
    ..claimMode = StartIssuanceInputClaimModeEnum.FIXED_HOLDER
    ..data = ListBuilder<StartIssuanceInputDataInner>([data.build()]);

  final response = await issuanceApi.startIssuance(
    projectId: projectId,
    startIssuanceInput: startIssuanceInput.build(),
  );

  print(response);
} catch (e) {
  print('Error obtaining token: $e');
}