feat!: store stake reg deposit in reward acct info

Chain history provider returns the stake registration certificates
from conway-era, which include the deposit value.
Store this value in the RewardAccountInfo, to be used at deregistration.

BREAKING CHANGE: `isLastStakeKeyCertOfType` was renamed to
`lastStakeKeyCertOfType` and returns the certificate or undefined.

Author: mirceahasegan

packages/core/src/Cardano/types/Certificate.ts

@@ -176,21 +176,19 @@ export type Certificate =
   | UnRegisterDelegateRepresentativeCertificate
   | UpdateDelegateRepresentativeCertificate;
 
-export const StakeRegistrationCertificateTypes = [
-  CertificateType.StakeRegistration,
+export const PostConwayStakeRegistrationCertificateTypes = [
   CertificateType.Registration,
   CertificateType.VoteRegistrationDelegation,
   CertificateType.StakeRegistrationDelegation,
   CertificateType.StakeVoteRegistrationDelegation
 ] as const;
 
-export type StakeRegistrationCertificateTypes = typeof StakeRegistrationCertificateTypes[number];
+export const StakeRegistrationCertificateTypes = [
+  CertificateType.StakeRegistration,
+  ...PostConwayStakeRegistrationCertificateTypes
+] as const;
 
-export type StakeDelegationCertificateUnion =
-  | StakeDelegationCertificate
-  | StakeVoteDelegationCertificate
-  | StakeRegistrationDelegationCertificate
-  | StakeVoteRegistrationDelegationCertificate;
+export type StakeRegistrationCertificateTypes = typeof StakeRegistrationCertificateTypes[number];
 
 export const StakeDelegationCertificateTypes = [
   CertificateType.StakeDelegation,
@@ -201,13 +199,6 @@ export const StakeDelegationCertificateTypes = [
 
 export type StakeDelegationCertificateTypes = typeof StakeDelegationCertificateTypes[number];
 
-export type RegAndDeregCertificateUnion =
-  | StakeAddressCertificate
-  | NewStakeAddressCertificate
-  | VoteRegistrationDelegationCertificate
-  | StakeRegistrationDelegationCertificate
-  | StakeVoteRegistrationDelegationCertificate;
-
 export const RegAndDeregCertificateTypes = [
   ...StakeRegistrationCertificateTypes,
   CertificateType.Unregistration,

packages/core/src/Cardano/types/DelegationsAndRewards.ts

@@ -29,6 +29,7 @@ export interface RewardAccountInfo {
   delegatee?: Delegatee;
   rewardBalance: Lovelace;
   // Maybe add rewardsHistory for each reward account too
+  deposit?: Lovelace; // defined only when keyStatus is Registered
 }
 
 export interface Cip17Pool {

packages/wallet/src/services/DelegationTracker/RewardAccounts.ts

@@ -25,7 +25,7 @@ import { RetryBackoffConfig } from 'backoff-rxjs';
 import { TrackedStakePoolProvider } from '../ProviderTracker';
 import { TxWithEpoch } from './types';
 import { coldObservableProvider } from '@cardano-sdk/util-rxjs';
-import { isLastStakeKeyCertOfType } from './transactionCertificates';
+import { lastStakeKeyCertOfType } from './transactionCertificates';
 import findLast from 'lodash/findLast';
 import isEqual from 'lodash/isEqual';
 import uniq from 'lodash/uniq';
@@ -124,15 +124,12 @@ export const createRewardsProvider =
     );
 export type ObservableRewardsProvider = ReturnType<typeof createRewardsProvider>;
 
-const isDelegationCertificate = (cert: Cardano.Certificate): cert is Cardano.StakeDelegationCertificateUnion =>
-  Cardano.StakeDelegationCertificateTypes.includes(cert.__typename as Cardano.StakeDelegationCertificateTypes);
-
 const getAccountsKeyStatus =
   (addresses: Cardano.RewardAccount[]) =>
   ([transactions, transactionsInFlight]: [TxWithEpoch[], TxInFlight[]]) => {
     const certificatesInFlight = transactionsInFlight.map(({ body: { certificates } }) => certificates || []);
     return addresses.map((address) => {
-      const isRegistered = isLastStakeKeyCertOfType(
+      const regCert = lastStakeKeyCertOfType(
         transactions.map(
           ({
             tx: {
@@ -143,23 +140,31 @@ const getAccountsKeyStatus =
         Cardano.StakeRegistrationCertificateTypes,
         address
       );
-      const isRegistering = isLastStakeKeyCertOfType(
+
+      let deposit: Cardano.Lovelace | undefined;
+      if (regCert && Cardano.isCertType(regCert, Cardano.PostConwayStakeRegistrationCertificateTypes)) {
+        deposit = regCert.deposit;
+      }
+
+      const isRegistering = !!lastStakeKeyCertOfType(
         certificatesInFlight,
         Cardano.StakeRegistrationCertificateTypes,
         address
       );
-      const isUnregistering = isLastStakeKeyCertOfType(
+      const isUnregistering = !!lastStakeKeyCertOfType(
         certificatesInFlight,
         [Cardano.CertificateType.StakeDeregistration, Cardano.CertificateType.Unregistration],
         address
       );
-      return isRegistering
+      const keyStatus = isRegistering
         ? Cardano.StakeKeyStatus.Registering
         : isUnregistering
         ? Cardano.StakeKeyStatus.Unregistering
-        : isRegistered
+        : regCert
         ? Cardano.StakeKeyStatus.Registered
         : Cardano.StakeKeyStatus.Unregistered;
+
+      return { ...(keyStatus === Cardano.StakeKeyStatus.Registered && { deposit }), keyStatus };
     });
   };
 
@@ -173,11 +178,15 @@ const accountCertificateTransactions = (
       transactions
         .map(({ tx, epoch }) => ({
           certificates: (tx.body.certificates || [])
-            .filter((cert): cert is Cardano.RegAndDeregCertificateUnion | Cardano.StakeDelegationCertificateUnion =>
-              [...Cardano.RegAndDeregCertificateTypes, ...Cardano.StakeDelegationCertificateTypes].includes(
-                cert.__typename as Cardano.RegAndDeregCertificateTypes | Cardano.StakeDelegationCertificateTypes
-              )
+            .map((cert) =>
+              Cardano.isCertType(cert, [
+                ...Cardano.RegAndDeregCertificateTypes,
+                ...Cardano.StakeDelegationCertificateTypes
+              ])
+                ? cert
+                : null
             )
+            .filter(isNotNil)
             .filter((cert) => (cert.stakeCredential.hash as unknown as Crypto.Ed25519KeyHashHex) === stakeKeyHash),
           epoch
         }))
@@ -204,15 +213,19 @@ export const getStakePoolIdAtEpoch = (transactions: TransactionsCertificates) =>
   const certificatesUpToEpoch = transactions
     .filter(({ epoch }) => epoch < atEpoch - 2)
     .map(({ certificates }) => certificates);
-  if (!isLastStakeKeyCertOfType(certificatesUpToEpoch, Cardano.StakeRegistrationCertificateTypes)) {
+  if (!lastStakeKeyCertOfType(certificatesUpToEpoch, Cardano.StakeRegistrationCertificateTypes)) {
     return;
   }
 
   const delegationTxCertificates = findLast(certificatesUpToEpoch, (certs) =>
     Cardano.includesAnyCertificate(certs, Cardano.StakeDelegationCertificateTypes)
   );
   if (!delegationTxCertificates) return;
-  return findLast(delegationTxCertificates.filter(isDelegationCertificate))?.poolId;
+  return findLast(
+    delegationTxCertificates
+      .map((cert) => (Cardano.isCertType(cert, Cardano.StakeDelegationCertificateTypes) ? cert : null))
+      .filter(isNotNil)
+  )?.poolId;
 };
 
 export const createDelegateeTracker = (
@@ -304,15 +317,16 @@ export const addressRewards = (
 export const toRewardAccounts =
   (addresses: Cardano.RewardAccount[]) =>
   ([statuses, delegatees, rewards]: [
-    Cardano.StakeKeyStatus[],
+    { keyStatus: Cardano.StakeKeyStatus; deposit?: Cardano.Lovelace }[],
     (Cardano.Delegatee | undefined)[],
     Cardano.Lovelace[]
   ]) =>
     addresses.map(
       (address, i): Cardano.RewardAccountInfo => ({
         address,
         delegatee: delegatees[i],
-        keyStatus: statuses[i],
+        deposit: statuses[i].deposit,
+        keyStatus: statuses[i].keyStatus,
         rewardBalance: rewards[i]
       })
     );

packages/wallet/src/services/DelegationTracker/transactionCertificates.ts

@@ -5,9 +5,9 @@ import { isNotNil } from '@cardano-sdk/util';
 import { transactionsEquals } from '../util/equals';
 import last from 'lodash/last';
 
-export const isLastStakeKeyCertOfType = (
+export const lastStakeKeyCertOfType = <K extends Cardano.RegAndDeregCertificateTypes>(
   transactionsCertificates: Cardano.Certificate[][],
-  certTypes: readonly Cardano.RegAndDeregCertificateTypes[],
+  certTypes: readonly K[],
   rewardAccount?: Cardano.RewardAccount
 ) => {
   const stakeKeyHash = rewardAccount
@@ -24,7 +24,10 @@ export const isLastStakeKeyCertOfType = (
       })
       .filter(isNotNil)
   );
-  return certTypes.includes(lastRegOrDereg?.__typename as Cardano.RegAndDeregCertificateTypes);
+
+  if (lastRegOrDereg && Cardano.isCertType(lastRegOrDereg, certTypes)) {
+    return lastRegOrDereg;
+  }
 };
 
 export const transactionsWithCertificates = (

packages/wallet/test/services/DelegationTracker/DelegationTracker.test.ts

@@ -103,17 +103,35 @@ describe('DelegationTracker', () => {
     it('does not emit outgoing transactions with certificates not signed by the reward accounts', () => {
       createTestScheduler().run(({ cold, expectObservable }) => {
         const rewardAccount = Cardano.RewardAccount('stake_test1upqykkjq3zhf4085s6n70w8cyp57dl87r0ezduv9rnnj2uqk5zmdv');
+        const foreignRewardAccount = Cardano.RewardAccount(
+          'stake_test1up7pvfq8zn4quy45r2g572290p9vf99mr9tn7r9xrgy2l2qdsf58d'
+        );
         const transactions = [
           createStubTxWithCertificates([
-            { __typename: Cardano.CertificateType.StakeRegistration } as Cardano.Certificate
+            {
+              __typename: Cardano.CertificateType.StakeRegistration,
+              stakeCredential: {
+                hash: Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(Cardano.RewardAccount.toHash(foreignRewardAccount))
+              }
+            } as Cardano.Certificate
           ]),
           createStubTxWithCertificates([
             { __typename: Cardano.CertificateType.PoolRetirement } as Cardano.Certificate,
-            { __typename: Cardano.CertificateType.StakeDelegation } as Cardano.Certificate
+            {
+              __typename: Cardano.CertificateType.StakeDelegation,
+              stakeCredential: {
+                hash: Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(Cardano.RewardAccount.toHash(foreignRewardAccount))
+              }
+            } as Cardano.Certificate
           ]),
           createStubTxWithCertificates(),
           createStubTxWithCertificates([
-            { __typename: Cardano.CertificateType.StakeDeregistration } as Cardano.Certificate
+            {
+              __typename: Cardano.CertificateType.StakeDeregistration,
+              stakeCredential: {
+                hash: Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(Cardano.RewardAccount.toHash(foreignRewardAccount))
+              }
+            } as Cardano.Certificate
           ])
         ];
         const slotEpochCalc = jest.fn().mockReturnValueOnce(284).mockReturnValueOnce(285);

packages/wallet/test/services/DelegationTracker/RewardAccounts.test.ts

@@ -217,7 +217,6 @@ describe('RewardAccounts', () => {
 
   test.each([
     Cardano.CertificateType.Registration,
-    Cardano.CertificateType.StakeRegistration,
     Cardano.CertificateType.StakeRegistrationDelegation,
     Cardano.CertificateType.StakeVoteRegistrationDelegation,
     Cardano.CertificateType.VoteRegistrationDelegation
@@ -321,10 +320,10 @@ describe('RewardAccounts', () => {
       });
       const tracker$ = addressKeyStatuses([rewardAccount], transactions$, transactionsInFlight$);
       expectObservable(tracker$).toBe('abcda', {
-        a: [Cardano.StakeKeyStatus.Unregistered],
-        b: [Cardano.StakeKeyStatus.Registering],
-        c: [Cardano.StakeKeyStatus.Registered],
-        d: [Cardano.StakeKeyStatus.Unregistering]
+        a: [{ keyStatus: Cardano.StakeKeyStatus.Unregistered }],
+        b: [{ keyStatus: Cardano.StakeKeyStatus.Registering }],
+        c: [{ deposit: 0n, keyStatus: Cardano.StakeKeyStatus.Registered }],
+        d: [{ keyStatus: Cardano.StakeKeyStatus.Unregistering }]
       });
     });
   });

packages/wallet/test/services/DelegationTracker/transactionCertificates.test.ts

@@ -1,10 +1,10 @@
 import * as Crypto from '@cardano-sdk/crypto';
 import { Cardano } from '@cardano-sdk/core';
 import { createTestScheduler } from '@cardano-sdk/util-dev';
-import { isLastStakeKeyCertOfType, transactionsWithCertificates } from '../../../src';
+import { lastStakeKeyCertOfType, transactionsWithCertificates } from '../../../src';
 
 describe('transactionCertificates', () => {
-  test('isLastStakeKeyCertOfType', () => {
+  test('lastStakeKeyCertOfType', () => {
     const rewardAccount = Cardano.RewardAccount('stake_test1up7pvfq8zn4quy45r2g572290p9vf99mr9tn7r9xrgy2l2qdsf58d');
     const stakeKeyHash = Cardano.RewardAccount.toHash(rewardAccount);
     const stakeCredential = {
@@ -15,7 +15,8 @@ describe('transactionCertificates', () => {
     const certificates = [
       [
         {
-          __typename: Cardano.CertificateType.StakeRegistration,
+          __typename: Cardano.CertificateType.Registration,
+          deposit: 2_000_000n,
           stakeCredential
         } as Cardano.Certificate,
         {
@@ -26,19 +27,22 @@ describe('transactionCertificates', () => {
       [
         ({ __typename: Cardano.CertificateType.PoolRegistration } as Cardano.Certificate,
         {
-          __typename: Cardano.CertificateType.StakeDeregistration,
+          __typename: Cardano.CertificateType.Unregistration,
+          deposit: 2_000_000n,
           stakeCredential: {
             hash: Crypto.Hash28ByteBase16('00000000000000000000000000000000000000000000000000000000'),
             type: Cardano.CredentialType.KeyHash
           }
         } as Cardano.Certificate)
       ]
     ];
-    expect(isLastStakeKeyCertOfType(certificates, [Cardano.CertificateType.StakeRegistration])).toBe(false);
-    expect(isLastStakeKeyCertOfType(certificates, [Cardano.CertificateType.StakeRegistration], rewardAccount)).toBe(
-      true
+    expect(lastStakeKeyCertOfType(certificates, [Cardano.CertificateType.Registration])).toBeFalsy();
+    expect(lastStakeKeyCertOfType(certificates, [Cardano.CertificateType.Registration], rewardAccount)).toEqual(
+      expect.objectContaining({ __typename: Cardano.CertificateType.Registration, deposit: 2_000_000n })
+    );
+    expect(lastStakeKeyCertOfType(certificates, [Cardano.CertificateType.Unregistration])).toEqual(
+      expect.objectContaining({ __typename: Cardano.CertificateType.Unregistration, deposit: 2_000_000n })
     );
-    expect(isLastStakeKeyCertOfType(certificates, [Cardano.CertificateType.StakeDeregistration])).toBe(true);
   });
 
   test('outgoingTransactionsWithCertificates', () => {