refactor: more flexible extrinsic unwrapping for ctype fetching (#837)

* refactor!: flattenCalls unpacks all calls
* test: add integration tests for dispatchAs
* fix: add conditional logic to event & extrinsic matching
* docs: update docstring on flattenCalls

Author: rflechtner

packages/asset-credentials/src/credentials/PublicCredential.chain.ts

@@ -14,9 +14,7 @@ import type {
   Did,
   HexString,
 } from '@kiltprotocol/types'
-import type { ApiPromise } from '@polkadot/api'
 import type { GenericCall, Option } from '@polkadot/types'
-import type { Call } from '@polkadot/types/interfaces'
 import type { BN } from '@polkadot/util'
 import type {
   PublicCredentialsCredentialsCredential,
@@ -125,28 +123,6 @@ export function fromChain(
 }
 
 // Given a (nested) call, flattens them and filter by calls that are of type `api.tx.publicCredentials.add`.
-function extractPublicCredentialCreationCallsFromDidCall(
-  api: ApiPromise,
-  call: Call
-): Array<GenericCall<typeof api.tx.publicCredentials.add.args>> {
-  const extrinsicCalls = Blockchain.flattenCalls(call, api)
-  return extrinsicCalls.filter(
-    (c): c is GenericCall<typeof api.tx.publicCredentials.add.args> =>
-      api.tx.publicCredentials.add.is(c)
-  )
-}
-
-// Given a (nested) call, flattens them and filter by calls that are of type `api.tx.did.submitDidCall`.
-function extractDidCallsFromBatchCall(
-  api: ApiPromise,
-  call: Call
-): Array<GenericCall<typeof api.tx.did.submitDidCall.args>> {
-  const extrinsicCalls = Blockchain.flattenCalls(call, api)
-  return extrinsicCalls.filter(
-    (c): c is GenericCall<typeof api.tx.did.submitDidCall.args> =>
-      api.tx.did.submitDidCall.is(c)
-  )
-}
 
 /**
  * Retrieves from the blockchain the {@link IPublicCredential} that is identified by the provided identifier.
@@ -164,14 +140,19 @@ export async function fetchCredentialFromChain(
   const publicCredentialEntry = await api.call.publicCredentials.getById(
     credentialId
   )
-  const { blockNumber, revoked } = publicCredentialEntry.unwrap()
+  const {
+    blockNumber,
+    revoked,
+    attester: attesterId,
+  } = publicCredentialEntry.unwrap()
+  const attester = didFromChain(attesterId)
 
   const extrinsic = await Blockchain.retrieveExtrinsicFromBlock(
     blockNumber,
     ({ events }) =>
       events.some(
         (event) =>
-          api.events.publicCredentials.CredentialStored.is(event) &&
+          api.events.publicCredentials?.CredentialStored?.is(event) &&
           event.data[1].toString() === credentialId
       ),
     api
@@ -183,58 +164,40 @@ export async function fetchCredentialFromChain(
     )
   }
 
-  if (
-    !Blockchain.isBatch(extrinsic, api) &&
-    !api.tx.did.submitDidCall.is(extrinsic)
-  ) {
-    throw new SDKErrors.PublicCredentialError(
-      'Extrinsic should be either a `did.submitDidCall` extrinsic or a batch with at least a `did.submitDidCall` extrinsic'
-    )
-  }
-
-  // If we're dealing with a batch, flatten any nested `submit_did_call` calls,
-  // otherwise the extrinsic is itself a submit_did_call, so just take it.
-  const didCalls = Blockchain.isBatch(extrinsic, api)
-    ? extrinsic.args[0].flatMap((batchCall) =>
-        extractDidCallsFromBatchCall(api, batchCall)
-      )
-    : [extrinsic]
-
-  // From the list of DID calls, only consider public_credentials::add calls, bundling each of them with their DID submitter.
-  // It returns a list of [reconstructedCredential, attesterDid].
-  const callCredentialsContent = didCalls.flatMap((didCall) => {
-    const publicCredentialCalls =
-      extractPublicCredentialCreationCallsFromDidCall(api, didCall.args[0].call)
-    // Re-create the issued public credential for each call identified.
-    return publicCredentialCalls.map(
-      (credentialCreationCall) =>
-        [
-          credentialInputFromChain(credentialCreationCall.args[0]),
-          didFromChain(didCall.args[0].did),
-        ] as const
-    )
-  })
+  // Unpack any nested calls, e.g., within a batch or `submit_did_call`
+  const extrinsicCalls = Blockchain.flattenCalls(extrinsic, api)
 
-  // If more than one call is present, it always considers the last one as the valid one, and takes its attester.
-  const lastRightCredentialCreationCall = callCredentialsContent
-    .reverse()
-    .find(([credential, attester]) => {
-      const reconstructedId = getIdForCredential(credential, attester)
-      return reconstructedId === credentialId
-    })
+  // only consider public_credentials::add calls
+  const publicCredentialCalls = extrinsicCalls.filter(
+    (c): c is GenericCall<typeof api.tx.publicCredentials.add.args> =>
+      api.tx.publicCredentials?.add?.is(c)
+  )
 
-  if (!lastRightCredentialCreationCall) {
+  // Re-create the issued public credential for each call identified to find the credential with the id we're looking for
+  const credentialInput = publicCredentialCalls.reduceRight<
+    IPublicCredentialInput | undefined
+  >((selectedCredential, credentialCreationCall) => {
+    if (selectedCredential) {
+      return selectedCredential
+    }
+    const credential = credentialInputFromChain(credentialCreationCall.args[0])
+    const reconstructedId = getIdForCredential(credential, attester)
+    if (reconstructedId === credentialId) {
+      return credential
+    }
+    return undefined
+  }, undefined)
+
+  if (typeof credentialInput === 'undefined') {
     throw new SDKErrors.PublicCredentialError(
       'Block should always contain the full credential, eventually.'
     )
   }
 
-  const [credentialInput, attester] = lastRightCredentialCreationCall
-
   return {
     ...credentialInput,
     attester,
-    id: getIdForCredential(credentialInput, attester),
+    id: credentialId,
     blockNumber,
     revoked: revoked.toPrimitive(),
   }

packages/chain-helpers/package.json

@@ -34,6 +34,7 @@
     "typescript": "^4.8.3"
   },
   "dependencies": {
+    "@kiltprotocol/augment-api": "workspace:^",
     "@kiltprotocol/config": "workspace:*",
     "@kiltprotocol/type-definitions": "workspace:*",
     "@kiltprotocol/types": "workspace:*",

packages/chain-helpers/src/blockchain/Blockchain.ts

@@ -5,11 +5,13 @@
  * found in the LICENSE file in the root directory of this source tree.
  */
 
+import '@kiltprotocol/augment-api'
+
 import type { ApiPromise } from '@polkadot/api'
 import type { TxWithEvent } from '@polkadot/api-derive/types'
-import type { GenericCall, GenericExtrinsic, Vec } from '@polkadot/types'
+import type { Vec } from '@polkadot/types'
 import type { Call, Extrinsic } from '@polkadot/types/interfaces'
-import type { AnyNumber } from '@polkadot/types/types'
+import type { AnyNumber, IMethod } from '@polkadot/types/types'
 import type { BN } from '@polkadot/util'
 
 import type {
@@ -210,31 +212,50 @@ export async function signAndSubmitTx(
  * @returns True if it's a batch, false otherwise.
  */
 export function isBatch(
-  extrinsic: Extrinsic | Call,
+  extrinsic: IMethod,
   api?: ApiPromise
-): extrinsic is GenericExtrinsic<[Vec<Call>]> | GenericCall<[Vec<Call>]> {
+): extrinsic is IMethod<[Vec<Call>]> {
   const apiPromise = api ?? ConfigService.get('api')
   return (
-    apiPromise.tx.utility.batch.is(extrinsic) ||
-    apiPromise.tx.utility.batchAll.is(extrinsic) ||
-    apiPromise.tx.utility.forceBatch.is(extrinsic)
+    apiPromise.tx.utility?.batch?.is(extrinsic) ||
+    apiPromise.tx.utility?.batchAll?.is(extrinsic) ||
+    apiPromise.tx.utility?.forceBatch?.is(extrinsic)
   )
 }
 
 /**
- * Flatten all calls into a single array following a DFS approach.
+ * Flatten all nested calls into a single array following a DFS approach.
  *
  * For example, given the calls [[N1, N2], [N3, [N4, N5], N6]], the final list will look like [N1, N2, N3, N4, N5, N6].
  *
+ * The following extrinsics are recognized as containing nested calls and will be unpacked:
+ *
+ * - pallet `utility`: `batch`, `batchAll`, `forceBatch`.
+ * - pallet `did`: `submitDidCall`, `dispatchAs`.
+ * - pallet `proxy`: `proxy`, `proxyAnnounced`.
+ *
  * @param call The {@link Call} which can potentially contain nested calls.
  * @param api The optional {@link ApiPromise}. If not provided, the one returned by the `ConfigService` is used.
  *
  * @returns A list of {@link Call} nested according to the rules above.
  */
-export function flattenCalls(call: Call, api?: ApiPromise): Call[] {
-  if (isBatch(call, api)) {
+export function flattenCalls(call: IMethod, api?: ApiPromise): IMethod[] {
+  const apiObject = api ?? ConfigService.get('api')
+  if (isBatch(call, apiObject)) {
     // Inductive case
-    return call.args[0].flatMap((c) => flattenCalls(c, api))
+    return call.args[0].flatMap((c) => flattenCalls(c, apiObject))
+  }
+  if (apiObject.tx.did?.submitDidCall?.is(call)) {
+    return flattenCalls(call.args[0].call, apiObject)
+  }
+  if (apiObject.tx.did?.dispatchAs?.is(call)) {
+    return flattenCalls(call.args[1], apiObject)
+  }
+  if (apiObject.tx.proxy?.proxy?.is(call)) {
+    return flattenCalls(call.args[2], apiObject)
+  }
+  if (apiObject.tx.proxy?.proxyAnnounced?.is(call)) {
+    return flattenCalls(call.args[3], apiObject)
   }
   // Base case
   return [call]

packages/credentials/src/V1/KiltAttestationProofV1.ts

@@ -244,7 +244,7 @@ async function verifyAttestedAt(
     .find(
       ({ phase, event }) =>
         phase.isApplyExtrinsic &&
-        api.events.attestation.AttestationCreated.is(event) &&
+        api.events.attestation?.AttestationCreated?.is(event) &&
         u8aEq(event.data[1], claimHash)
     )
   if (!attestationEvent)

packages/credentials/src/ctype/CType.chain.ts

@@ -5,9 +5,8 @@
  * found in the LICENSE file in the root directory of this source tree.
  */
 
-import type { ApiPromise } from '@polkadot/api'
 import type { Bytes, GenericCall, Option } from '@polkadot/types'
-import type { AccountId, Call } from '@polkadot/types/interfaces'
+import type { AccountId } from '@polkadot/types/interfaces'
 import type { BN } from '@polkadot/util'
 
 import type { CtypeCtypeEntry } from '@kiltprotocol/augment-api'
@@ -118,30 +117,6 @@ export function fromChain(
   }
 }
 
-// Given a (nested) call, flattens them and filter by calls that are of type `api.tx.ctype.add`.
-function extractCTypeCreationCallsFromDidCall(
-  api: ApiPromise,
-  call: Call
-): Array<GenericCall<typeof api.tx.ctype.add.args>> {
-  const extrinsicCalls = Blockchain.flattenCalls(call, api)
-  return extrinsicCalls.filter(
-    (c): c is GenericCall<typeof api.tx.ctype.add.args> =>
-      api.tx.ctype.add.is(c)
-  )
-}
-
-// Given a (nested) call, flattens them and filter by calls that are of type `api.tx.did.submitDidCall`.
-function extractDidCallsFromBatchCall(
-  api: ApiPromise,
-  call: Call
-): Array<GenericCall<typeof api.tx.did.submitDidCall.args>> {
-  const extrinsicCalls = Blockchain.flattenCalls(call, api)
-  return extrinsicCalls.filter(
-    (c): c is GenericCall<typeof api.tx.did.submitDidCall.args> =>
-      api.tx.did.submitDidCall.is(c)
-  )
-}
-
 /**
  * Resolves a CType identifier to the CType definition by fetching data from the block containing the transaction that registered the CType on chain.
  *
@@ -156,7 +131,7 @@ export async function fetchFromChain(
   const cTypeHash = idToHash(cTypeId)
 
   const cTypeEntry = await api.query.ctype.ctypes(cTypeHash)
-  const { createdAt } = fromChain(cTypeEntry)
+  const { createdAt, creator } = fromChain(cTypeEntry)
   if (typeof createdAt === 'undefined')
     throw new SDKErrors.CTypeError(
       'Cannot fetch CType definitions on a chain that does not store the createdAt block'
@@ -167,72 +142,52 @@ export async function fetchFromChain(
     ({ events }) =>
       events.some(
         (event) =>
-          api.events.ctype.CTypeCreated.is(event) &&
-          event.data[1].toString() === cTypeHash
+          api.events.ctype?.CTypeCreated?.is(event) &&
+          event.data[1].toHex() === cTypeHash
       ),
     api
   )
 
   if (extrinsic === null) {
     throw new SDKErrors.CTypeError(
-      `There is not CType with the provided ID "${cTypeId}" on chain.`
+      `There is no CType with the provided ID "${cTypeId}" on chain.`
     )
   }
 
-  if (
-    !Blockchain.isBatch(extrinsic, api) &&
-    !api.tx.did.submitDidCall.is(extrinsic)
-  ) {
-    throw new SDKErrors.PublicCredentialError(
-      'Extrinsic should be either a `did.submitDidCall` extrinsic or a batch with at least a `did.submitDidCall` extrinsic'
-    )
-  }
+  // Unpack any nested calls, e.g., within a batch or `submit_did_call`
+  const extrinsicCalls = Blockchain.flattenCalls(extrinsic, api)
 
-  // If we're dealing with a batch, flatten any nested `submit_did_call` calls,
-  // otherwise the extrinsic is itself a submit_did_call, so just take it.
-  const didCalls = Blockchain.isBatch(extrinsic, api)
-    ? extrinsic.args[0].flatMap((batchCall) =>
-        extractDidCallsFromBatchCall(api, batchCall)
-      )
-    : [extrinsic]
-
-  // From the list of DID calls, only consider ctype::add calls, bundling each of them with their DID submitter.
-  // It returns a list of [reconstructedCType, attesterDid].
-  const ctypeCallContent = didCalls.flatMap((didCall) => {
-    const ctypeCreationCalls = extractCTypeCreationCallsFromDidCall(
-      api,
-      didCall.args[0].call
-    )
-    // Re-create the issued public credential for each call identified.
-    return ctypeCreationCalls.map(
-      (ctypeCreationCall) =>
-        [
-          cTypeInputFromChain(ctypeCreationCall.args[0]),
-          Did.fromChain(didCall.args[0].did),
-        ] as const
-    )
-  })
+  // only consider ctype::add calls
+  const ctypeCreationCalls = extrinsicCalls.filter(
+    (c): c is GenericCall<typeof api.tx.ctype.add.args> =>
+      api.tx.ctype?.add?.is(c)
+  )
 
-  // If more than a call is present, it always considers the last one as the valid one.
-  const lastRightCTypeCreationCall = ctypeCallContent
-    .reverse()
-    .find((cTypeInput) => {
-      return cTypeInput[0].$id === cTypeId
-    })
+  // Re-create the ctype for each call identified to find the right ctype.
+  // If more than one matching call is present, it always considers the last one as the valid one.
+  const cTypeDefinition = ctypeCreationCalls.reduceRight<ICType | undefined>(
+    (selectedCType, cTypeCreationCall) => {
+      if (selectedCType) {
+        return selectedCType
+      }
+      const cType = cTypeInputFromChain(cTypeCreationCall.args[0])
+
+      if (cType.$id === cTypeId) {
+        return cType
+      }
+      return undefined
+    },
+    undefined
+  )
 
-  if (!lastRightCTypeCreationCall) {
+  if (typeof cTypeDefinition === 'undefined') {
     throw new SDKErrors.CTypeError(
       'Block should always contain the full CType, eventually.'
     )
   }
 
-  const [ctypeInput, creator] = lastRightCTypeCreationCall
-
   return {
-    cType: {
-      ...ctypeInput,
-      $id: cTypeId,
-    },
+    cType: cTypeDefinition,
     creator,
     createdAt,
   }