fix(evm-decoder): correct token target, confidence and failure fallback

- ERC20 sub-protocols report the token recipient as `to`; resolve the token
  contract from the protocol instead, and leave the target unknown rather
  than naming the recipient as the contract.
- transfer/approve are only 'high' confidence for a curated token contract;
  the selector alone gives 'medium'.
- a decode that throws now shows the raw-calldata view with its warning
  instead of hiding the decoder panel.
- drop stale results when ngOnInit/ngOnChanges decode runs overlap.
- build the signature DB for the electron and no-sapling builds too.

Author: AndreasGassmann

package.json

@@ -15,11 +15,11 @@
     "smoke:evm": "node scripts/smoke-decoder.mjs && node scripts/smoke-renderer.mjs",
     "build": "yarn build:signatures && ng build",
     "build:prod": "yarn build:signatures && ng build --configuration production",
-    "build:no-sapling": "yarn remove-sapling && yarn prepare-prod-build && ng build --configuration production",
+    "build:no-sapling": "yarn remove-sapling && yarn prepare-prod-build && yarn build:signatures && ng build --configuration production",
     "build:stats": "ng build --stats-json",
     "build:analyze": "yarn build:stats && webpack-bundle-analyzer ./www/stats.json",
-    "build:electron": "ng build --base-href=./",
-    "build:electron:prod": "ng build --base-href=./ --configuration production",
+    "build:electron": "yarn build:signatures && ng build --base-href=./",
+    "build:electron:prod": "yarn build:signatures && ng build --base-href=./ --configuration production",
     "memory": "node --max_old_space_size=8048 ./node_modules/@angular/cli/bin/ng serve --port 4201",
     "test": "ng test",
     "test-ci": "node --max_old_space_size=8192 ./node_modules/@angular/cli/bin/ng test --code-coverage --watch=false",

src/app/components/transaction/transaction.component.evm.e2e.spec.ts

@@ -7,15 +7,16 @@
  * the runtime parser, binary search and renderer pipeline are all exercised
  * end-to-end against rendered DOM.
  */
-import { ClipboardService } from '@airgap/angular-core'
+import { ClipboardService, ProtocolService } from '@airgap/angular-core'
 import { HttpClient } from '@angular/common/http'
 import { ComponentFixture, TestBed } from '@angular/core/testing'
 import { IonicModule } from '@ionic/angular'
 import { TranslateModule, TranslateService } from '@ngx-translate/core'
-import { IAirGapTransaction, MainProtocolSymbols } from '@airgap/coinlib-core'
+import { IAirGapTransaction, MainProtocolSymbols, SubProtocolSymbols } from '@airgap/coinlib-core'
 import { of } from 'rxjs'
 
 import { ContactsService } from '../../services/contacts/contacts.service'
+import { EvmTransactionRendererService } from '../../services/evm/transaction-renderer.service'
 import { EvmTransactionDisplayComponent } from '../evm-transaction-display/evm-transaction-display.component'
 import { TransactionWarningComponent } from '../transaction-warning/transaction-warning.component'
 import enJson from '../../../assets/i18n/en.json'
@@ -114,6 +115,7 @@ describe('TransactionComponent — EVM decoder (e2e)', () => {
   let component: TransactionComponent
   let fixture: ComponentFixture<TransactionComponent>
   const contactsSpy = jasmine.createSpyObj('ContactsService', ['isBookEnabled', 'getContactName'])
+  const protocolSpy = jasmine.createSpyObj('ProtocolService', ['getProtocol'])
 
   beforeEach(async () => {
     contactsSpy.isBookEnabled.and.returnValue(Promise.resolve(false))
@@ -124,7 +126,8 @@ describe('TransactionComponent — EVM decoder (e2e)', () => {
       providers: [
         { provide: HttpClient, useClass: FakeHttpClient },
         { provide: ContactsService, useValue: contactsSpy },
-        { provide: ClipboardService, useValue: jasmine.createSpyObj('ClipboardService', ['copyAndShowToast']) }
+        { provide: ClipboardService, useValue: jasmine.createSpyObj('ClipboardService', ['copyAndShowToast']) },
+        { provide: ProtocolService, useValue: protocolSpy }
       ]
     })
       // Schemas: the real TransactionComponent template uses pipes (amountConverter / feeConverter)
@@ -169,6 +172,34 @@ describe('TransactionComponent — EVM decoder (e2e)', () => {
     expect(text).toContain('0xd8da6bf26964af9d7eed9e03e53415d37aa96045')
   })
 
+  it('uses the token contract, not the recipient in `to`, for ERC-20 sub-protocols', async () => {
+    protocolSpy.getProtocol.and.returnValue(
+      Promise.resolve({ getContractAddress: () => Promise.resolve('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48') })
+    )
+    await runWith([
+      evmTx({
+        // coinlib's ERC20 protocol reports the token recipient as `to`
+        to: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
+        protocolIdentifier: SubProtocolSymbols.ETH_ERC20,
+        data:
+          '0xa9059cbb' +
+          '000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045' +
+          '00000000000000000000000000000000000000000000000000000000000f4240'
+      })
+    ])
+    const text = (fixture.nativeElement as HTMLElement).textContent || ''
+    expect(text).toContain('1 USDC')
+    expect(text).toContain('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
+  })
+
+  it('renders raw calldata with a warning when decoding throws', async () => {
+    const renderer = TestBed.inject(EvmTransactionRendererService)
+    spyOn(renderer, 'render').and.throwError('boom')
+    await runWith([evmTx({ to: '0xabcabcabcabcabcabcabcabcabcabcabcabcabca', data: '0x12345678' })])
+    const text = (fixture.nativeElement as HTMLElement).textContent || ''
+    expect(text).toContain('Could not decode')
+  })
+
   it('renders an unlimited approval in warning style', async () => {
     await runWith([
       evmTx({

src/app/components/transaction/transaction.component.spec.ts

@@ -8,7 +8,7 @@ import { SecureStorageService } from 'src/app/services/secure-storage/secure-sto
 import { SecureStorageServiceMock } from 'src/app/services/secure-storage/secure-storage.mock'
 import { InteractionService } from 'src/app/services/interaction/interaction.service'
 import { createAppSpy } from 'test-config/plugins-mocks'
-import { APP_PLUGIN, DeeplinkService } from '@airgap/angular-core'
+import { APP_PLUGIN, DeeplinkService, ProtocolService } from '@airgap/angular-core'
 
 describe('UnsignedTransactionComponent', () => {
   let signedTransactionFixture: ComponentFixture<TransactionComponent>
@@ -27,7 +27,8 @@ describe('UnsignedTransactionComponent', () => {
           SecretsService,
           InteractionService,
           DeeplinkService,
-          { provide: APP_PLUGIN, useValue: appSpy }
+          { provide: APP_PLUGIN, useValue: appSpy },
+          { provide: ProtocolService, useValue: jasmine.createSpyObj('ProtocolService', ['getProtocol']) }
         ]
       })
     )

src/app/components/transaction/transaction.component.ts

@@ -1,10 +1,11 @@
-import { IAirGapTransaction, ProtocolSymbols } from '@airgap/coinlib-core'
+import { ProtocolService } from '@airgap/angular-core'
+import { IAirGapTransaction, ICoinSubProtocol, ProtocolSymbols } from '@airgap/coinlib-core'
 import { Component, Input, OnInit } from '@angular/core'
 import { BehaviorSubject, Observable } from 'rxjs'
 import { ContactsService } from 'src/app/services/contacts/contacts.service'
 
-import { RenderResult } from '../../services/evm/abi-types'
-import { chainIdForProtocol, isEvmProtocol } from '../../services/evm/protocol-mapping'
+import { EvmTransactionInput, RenderResult } from '../../services/evm/abi-types'
+import { chainIdForProtocol, isEvmProtocol, isEvmSubProtocol } from '../../services/evm/protocol-mapping'
 import { EvmTransactionRendererService } from '../../services/evm/transaction-renderer.service'
 
 import { AggregatedDetails, TransactionStore } from './transaction.store'
@@ -30,11 +31,13 @@ export class TransactionComponent implements OnInit {
   public readonly evmResults$ = this.evmResultsSubject.asObservable()
   private readonly dbDateSubject = new BehaviorSubject<string | undefined>(undefined)
   public readonly dbDate$ = this.dbDateSubject.asObservable()
+  private decodeRun = 0
 
   constructor(
     private readonly store: TransactionStore,
     private readonly contactsService: ContactsService,
-    private readonly evmRenderer: EvmTransactionRendererService
+    private readonly evmRenderer: EvmTransactionRendererService,
+    private readonly protocolService: ProtocolService
   ) {
     this.protocolIdentifier$ = this.store.selectProtocolIdentifier()
     this.airGapTxs$ = this.store.selectAirGapTxs()
@@ -56,6 +59,8 @@ export class TransactionComponent implements OnInit {
   }
 
   private async decodeEvm(): Promise<void> {
+    // ngOnInit and every ngOnChanges start a run; only the latest may publish.
+    const run = ++this.decodeRun
     if (!this.airGapTxs) {
       this.evmResultsSubject.next([])
       return
@@ -65,24 +70,38 @@ export class TransactionComponent implements OnInit {
         if (!isEvmProtocol(tx.protocolIdentifier)) return null
         const data = tx.data
         if (!data || data === '0x' || data.length <= 2) return null
-        const to = tx.to?.[0]
-        if (!to) return null
-        const input = { to, data, chainId: chainIdForProtocol(tx.protocolIdentifier) }
+        let to: string | undefined
+        if (isEvmSubProtocol(tx.protocolIdentifier)) {
+          // Token protocols replace `to` with the token recipient; the called
+          // contract is the protocol's own. Unknown stays unknown, never the recipient.
+          to = await this.tokenContractAddress(tx)
+        } else {
+          to = tx.to?.[0]
+          if (!to) return null
+        }
+        const input: EvmTransactionInput = { to, data, chainId: chainIdForProtocol(tx.protocolIdentifier) }
         try {
           await this.evmRenderer.prepare(input)
           return this.evmRenderer.render(input)
         } catch (e) {
           console.warn('EVM decode failed', e)
-          return null
+          return this.evmRenderer.renderRaw(input)
         }
       })
     )
+    if (run !== this.decodeRun) return
     this.evmResultsSubject.next(results)
-    if (results.some(r => r)) {
-      const meta = await this.evmRenderer.getDbMetadata()
-      this.dbDateSubject.next(meta?.sourcifyExportDate)
-    } else {
-      this.dbDateSubject.next(undefined)
+    const meta = results.some(r => r) ? await this.evmRenderer.getDbMetadata() : undefined
+    if (run !== this.decodeRun) return
+    this.dbDateSubject.next(meta?.sourcifyExportDate)
+  }
+
+  private async tokenContractAddress(tx: IAirGapTransaction): Promise<string | undefined> {
+    try {
+      const protocol = (await this.protocolService.getProtocol(tx.protocolIdentifier, tx.network, false)) as ICoinSubProtocol
+      return (await protocol.getContractAddress?.()) || undefined
+    } catch {
+      return undefined
     }
   }
 

src/app/renderers/evm/erc20.renderer.ts

@@ -33,7 +33,8 @@ export class Erc20Renderer implements TransactionRenderer {
       : { valueKey: 'evm-decoder.amount-raw-note', valueParams: { value: amountRaw.toString() }, value: amountRaw.toString(), rawValue: amountRaw.toString() }
     return {
       type: 'erc20-transfer',
-      confidence: 'high',
+      // The selector alone proves nothing about the contract: only a curated token is 'high'.
+      confidence: token ? 'high' : 'medium',
       functionNameKey: 'evm-decoder.fn-token-transfer',
       rows: [
         { labelKey: 'evm-decoder.function-label', valueKey: 'evm-decoder.fn-token-transfer', value: 'Token Transfer', type: 'text' },
@@ -60,7 +61,7 @@ export class Erc20Renderer implements TransactionRenderer {
       : { valueKey: 'evm-decoder.amount-raw-note', valueParams: { value: amountRaw.toString() }, value: amountRaw.toString(), rawValue: amountRaw.toString() }
     return {
       type: 'erc20-approve',
-      confidence: 'high',
+      confidence: token ? 'high' : 'medium',
       functionNameKey: 'evm-decoder.fn-token-approval',
       rows: [
         { labelKey: 'evm-decoder.function-label', valueKey: 'evm-decoder.fn-token-approval', value: 'Token Approval', type: 'text' },

src/app/services/evm/protocol-mapping.ts

@@ -32,6 +32,10 @@ export function isEvmProtocol(id: ProtocolSymbols | string | undefined): boolean
   return EVM_MAIN.includes(id) || EVM_SUB.includes(id)
 }
 
+export function isEvmSubProtocol(id: ProtocolSymbols | string | undefined): boolean {
+  return !!id && EVM_SUB.includes(id)
+}
+
 export function chainIdForProtocol(id: ProtocolSymbols | string | undefined): number | undefined {
   if (!id) return undefined
   return CHAIN_ID[id]

src/app/services/evm/transaction-renderer.service.ts

@@ -101,6 +101,11 @@ export class EvmTransactionRendererService {
     return result
   }
 
+  /** Raw-calldata view with the "could not decode" warning, for when decoding itself fails. */
+  public renderRaw(tx: EvmTransactionInput): RenderResult {
+    return this.flagUnknownTarget(tx, this.rawHex.render(tx))
+  }
+
   /**
    * Attach curated well-known names (USDC, Uniswap V2: Router 2, …) to every
    * `address` row across the whole result tree. Single pass over all renderers'