feat: cleanup superhero id service code

Author: akalogerakisunicorn

src/composables/superheroId.ts

@@ -23,6 +23,7 @@ export function useSuperheroId(): {
   refreshHasSuperheroId: () => Promise<void>;
   syncAddressBook: (json: string) => Promise<void>;
   loadAddressBook: () => Promise<void>;
+  deployContract: () => Promise<string>;
 } { // eslint-disable-line
   const { aeAccounts } = useAccounts();
   const { getAeSdk } = useAeSdk();
@@ -34,13 +35,21 @@ export function useSuperheroId(): {
 
   const svcRef = superheroSvcRef as unknown as Ref<SuperheroIDService | null>;
 
+  function getService(): SuperheroIDService {
+    if (!(superheroSvcRef.value instanceof SuperheroIDService)) {
+      superheroSvcRef.value = new SuperheroIDService();
+    }
+    // TypeScript: assert concrete class
+    return superheroSvcRef.value as SuperheroIDService;
+  }
+
   async function refreshHasSuperheroId(): Promise<void> {
     const addr = firstAeAddress.value;
     if (!addr) {
       hasSuperheroIdRef.value = false;
       return;
     }
-    const svc = superheroSvcRef.value || new SuperheroIDService();
+    const svc = getService();
     try {
       hasSuperheroIdRef.value = await svc.hasId();
     } catch {
@@ -51,8 +60,7 @@ export function useSuperheroId(): {
   async function syncAddressBook(json: string): Promise<void> {
     const addr = firstAeAddress.value;
     if (!addr) throw new Error('No æternity account');
-    if (!superheroSvcRef.value) throw new Error('Connect Superhero ID first');
-    const svc = superheroSvcRef.value;
+    const svc = getService();
     const txBase64 = await svc.buildSetIdTx(json) as Encoded.Transaction;
     const tx = unpackTx(txBase64) as any;
     await openModal(MODAL_CONFIRM_TRANSACTION_SIGN, {
@@ -72,14 +80,21 @@ export function useSuperheroId(): {
   async function loadAddressBook() {
     const addr = firstAeAddress.value;
     if (!addr) throw new Error('No æternity account');
-    const svc = superheroSvcRef.value || new SuperheroIDService();
+    const svc = getService();
     const val = await svc.getId();
     hasSuperheroIdRef.value = !!val;
     if (val) {
       addAddressBookEntriesFromJson(val, false);
     }
   }
 
+  async function deployContract(): Promise<string> {
+    const svc = getService();
+    const res = await fetch('/contracts/SuperheroIds.aes');
+    const source = await res.text();
+    return svc.deployFromSource(source);
+  }
+
   // Re-init on network change if an AE account exists
   const { onNetworkChange } = useNetworks();
   onNetworkChange(async () => {
@@ -91,7 +106,6 @@ export function useSuperheroId(): {
     () => firstAeAddress.value,
     async (addr) => {
       if (addr) {
-        if (!superheroSvcRef.value) superheroSvcRef.value = new SuperheroIDService();
         await refreshHasSuperheroId();
       } else {
         superheroSvcRef.value = null;
@@ -107,5 +121,6 @@ export function useSuperheroId(): {
     refreshHasSuperheroId,
     syncAddressBook,
     loadAddressBook,
+    deployContract,
   };
 }

src/popup/locales/en.json

@@ -749,6 +749,9 @@
         "addressBook": "Address Book",
         "own": "Own",
         "recent": "Recent"
+      },
+      "superheroId": {
+        "synced": "Address Book Sync with SH ID completed"
       }
     },
     "secureLogin": {

src/popup/pages/AddressBook.vue

@@ -84,9 +84,8 @@ export default defineComponent({
         const addr = aeAccounts.value?.[0]?.address as `ak_${string}`;
         if (!addr) throw new Error('No æternity account');
         await syncAddressBook(JSON.stringify(addressBook.value));
-        openDefaultModal({ title: t('dashboard.superheroId.title'), msg: t('pages.addressBook.export.title') });
+        openDefaultModal({ title: t('dashboard.superheroId.title'), msg: t('pages.addressBook.superheroId.synced') });
       } catch (e) {
-        openDefaultModal({ title: t('dashboard.superheroId.title'), msg: t('common.connectionFailed') });
         handleUnknownError(e);
       } finally {
         isSyncing.value = false;

src/popup/pages/Dashboard.vue

@@ -192,7 +192,7 @@ export default defineComponent({
     const { multisigAccounts } = useMultisigAccounts();
     const { addressBook } = useAddressBook();
     const {
-      superheroSvc,
+      deployContract,
       hasSuperheroId,
       syncAddressBook,
       loadAddressBook,
@@ -228,15 +228,9 @@ export default defineComponent({
       pageIsActive.value = false;
     });
 
-    const connectedContractId = ref<string | null>(null);
-
     async function onDeployContract() {
       try {
-        const res = await fetch('/contracts/SuperheroIds.aes');
-        const source = await res.text();
-        const svc = superheroSvc.value!;
-        const ct = await svc.deployFromSource(source);
-        connectedContractId.value = ct;
+        const ct = await deployContract();
         openDefaultModal({ title: t('dashboard.superheroId.title'), msg: t('dashboard.superheroId.deployedMsg', { ct }) });
       } catch (e) {
         openDefaultModal({ title: t('dashboard.superheroId.title'), msg: t('dashboard.superheroId.deployFailed') });

src/protocols/aeternity/libs/SuperheroIDService.ts

@@ -1,5 +1,6 @@
 import {
   Contract,
+  ContractMethodsBase,
   Encoded,
   Tag,
 } from '@aeternity/aepp-sdk';
@@ -11,25 +12,27 @@ import { useAccounts } from '@/composables/accounts';
 import { encrypt, decrypt, importAesKeyFromSecret } from '@/utils/crypto';
 import type { IAccount } from '@/types';
 
-export type SuperheroIdsContract = Contract<{
-  set_id: (id: string) => Promise<void>;
-  get_id: () => Promise<{ decodedResult: string | undefined }>;
-  has_id: () => Promise<{ decodedResult: boolean }>;
-}>;
+interface SuperheroIdsContractMethods extends ContractMethodsBase {
+  set_id: (id: string) => void;
+  get_id: () => string | undefined;
+  has_id: () => boolean;
+}
+
+export type SuperheroIdsContract = Contract<SuperheroIdsContractMethods>;
 
 export class SuperheroIDService {
-  private contractId: Encoded.ContractAddress = 'ct_kaUS1K6qFXn2wP2phR26WLWXEKu5YsgA2gq4RWvkB69KY2gYF';
+  private contractId = 'ct_kaUS1K6qFXn2wP2phR26WLWXEKu5YsgA2gq4RWvkB69KY2gYF' as const;
 
   private async getContractInstance(options?: Partial<ContractInitializeOptions>):
     Promise<SuperheroIdsContract> {
     const { getAeSdk } = useAeSdk();
     const aeSdk = await getAeSdk();
-    return Contract.initialize({
+    return Contract.initialize<SuperheroIdsContractMethods>({
       ...aeSdk.getContext(),
       ...options,
-      aci: SuperheroIdsACI as any,
+      aci: SuperheroIdsACI,
       address: this.contractId,
-    }) as unknown as SuperheroIdsContract;
+    });
   }
 
   private static getCallerAccount(): IAccount {
@@ -45,8 +48,7 @@ export class SuperheroIDService {
     if (!account?.secretKey) throw new Error('Missing secret key for encryption');
     const key = await importAesKeyFromSecret(account.secretKey);
     const ciphertext = await encrypt(key, id);
-    await (contract as any)
-      .set_id(ciphertext, { fromAccount: account.address as Encoded.AccountAddress });
+    await contract.set_id(ciphertext);
   }
 
   async getId(): Promise<string | undefined> {
@@ -77,47 +79,46 @@ export class SuperheroIDService {
     if (!account?.secretKey) throw new Error('Missing secret key for encryption');
     const key = await importAesKeyFromSecret(account.secretKey);
     const ciphertext = await encrypt(key, id);
-    const gasLimit = await (contract as any)._estimateGas('set_id', [ciphertext], {
+    const gasLimit = await contract._estimateGas('set_id', [ciphertext], {
       senderId: account.address as Encoded.AccountAddress,
     });
-    const callData = (contract as any)._calldata.encode((contract as any)._name, 'set_id', [ciphertext]);
-    const built = await aeSdk.buildTx({
+    const callData = contract._calldata.encode(contract._name, 'set_id', [ciphertext]);
+    return aeSdk.buildTx({
       tag: Tag.ContractCallTx,
       callerId: account.address as Encoded.AccountAddress,
-      contractId: this.contractId!,
+      contractId: this.contractId,
       abiVersion: 3,
       amount: 0,
       callData,
       gasLimit,
-    } as any);
-    return built;
+    });
   }
 
   async deployContract(bytecode: Encoded.ContractBytearray): Promise<Encoded.ContractAddress> {
     const { getAeSdk } = useAeSdk();
     const aeSdk = await getAeSdk();
-    const instance = await Contract.initialize({
+    const instance = await Contract.initialize<SuperheroIdsContract>({
       ...aeSdk.getContext(),
-      aci: SuperheroIdsACI as any,
+      aci: SuperheroIdsACI,
       bytecode,
-    }) as any;
+    });
 
     await instance.init();
-    const address = instance.$options.address as Encoded.ContractAddress;
+    const { address } = instance.$options;
     this.contractId = address;
     return address;
   }
 
   async deployFromSource(sourceCode: string): Promise<Encoded.ContractAddress> {
     const { getAeSdk } = useAeSdk();
     const aeSdk = await getAeSdk();
-    const instance = await Contract.initialize({
+    const instance = await Contract.initialize<SuperheroIdsContract>({
       ...aeSdk.getContext(),
-      aci: SuperheroIdsACI as any,
+      aci: SuperheroIdsACI,
       sourceCode,
-    }) as any;
+    });
     await instance.init();
-    const address = instance.$options.address as Encoded.ContractAddress;
+    const { address } = instance.$options;
     this.contractId = address;
     return address;
   }