Merge pull request #1534 from input-output-hk/feat/lw-11756-add-drep-status-provider

Feat/lw 11756 add drep status provider

Author: AngelCastilloB

packages/cardano-services-client/src/DRepProvider/BlockfrostDRepProvider.ts

@@ -0,0 +1,37 @@
+import { BlockfrostClient } from '../blockfrost/BlockfrostClient';
+import { BlockfrostProvider } from '../blockfrost/BlockfrostProvider';
+import { Cardano, DRepInfo, DRepProvider, GetDRepInfoArgs, GetDRepsInfoArgs } from '@cardano-sdk/core';
+import { Logger } from 'ts-log';
+import type { Responses } from '@blockfrost/blockfrost-js';
+
+export class BlockfrostDRepProvider extends BlockfrostProvider implements DRepProvider {
+  constructor(client: BlockfrostClient, logger: Logger) {
+    super(client, logger);
+  }
+
+  async getDRepInfo({ id }: GetDRepInfoArgs): Promise<DRepInfo> {
+    try {
+      const cip105DRepId = Cardano.DRepID.toCip105DRepID(id); // Blockfrost only supports CIP-105 DRep IDs
+      const response = await this.request<Responses['drep']>(`governance/dreps/${cip105DRepId.toString()}`);
+      const amount = BigInt(response.amount);
+      const activeEpoch = response.active_epoch ? Cardano.EpochNo(response.active_epoch) : undefined;
+      const active = response.active;
+      const hasScript = response.has_script;
+
+      return {
+        active,
+        activeEpoch,
+        amount,
+        hasScript,
+        id
+      };
+    } catch (error) {
+      this.logger.error('getDRep failed', id);
+      throw this.toProviderError(error);
+    }
+  }
+
+  getDRepsInfo({ ids }: GetDRepsInfoArgs): Promise<DRepInfo[]> {
+    return Promise.all(ids.map((id) => this.getDRepInfo({ id })));
+  }
+}

packages/cardano-services-client/src/DRepProvider/index.ts

@@ -0,0 +1 @@
+export * from './BlockfrostDRepProvider';

packages/cardano-services-client/src/index.ts

@@ -4,6 +4,7 @@ export * from './TxSubmitProvider';
 export * from './StakePoolProvider';
 export * from './UtxoProvider';
 export * from './ChainHistoryProvider';
+export * from './DRepProvider';
 export * from './NetworkInfoProvider';
 export * from './RewardsProvider';
 export * from './HandleProvider';

packages/cardano-services-client/test/AssetInfoProvider/BlockfrostAssetProvider.test.ts

@@ -5,7 +5,7 @@ import type { Responses } from '@blockfrost/blockfrost-js';
 import { BlockfrostAssetProvider } from '../../src';
 import { BlockfrostClient } from '../../src/blockfrost/BlockfrostClient';
 import { logger } from '@cardano-sdk/util-dev';
-import { mockResponses } from './util';
+import { mockResponses } from '../util';
 
 describe('BlockfrostAssetProvider', () => {
   let request: jest.Mock;

packages/cardano-services-client/test/AssetInfoProvider/util.ts

@@ -0,0 +1,52 @@
+/* eslint-disable sonarjs/no-duplicate-string */
+import { Cardano, DRepInfo } from '@cardano-sdk/core';
+import type { Responses } from '@blockfrost/blockfrost-js';
+
+import { BlockfrostClient } from '../../src/blockfrost/BlockfrostClient';
+import { BlockfrostDRepProvider } from '../../src';
+import { logger } from '@cardano-sdk/util-dev';
+import { mockResponses } from '../util';
+
+describe('BlockfrostDRepProvider', () => {
+  let request: jest.Mock;
+  let provider: BlockfrostDRepProvider;
+
+  beforeEach(() => {
+    request = jest.fn();
+    const client = { request } as unknown as BlockfrostClient;
+    provider = new BlockfrostDRepProvider(client, logger);
+  });
+
+  describe('getDRep', () => {
+    const mockedDRepId = Cardano.DRepID('drep15cfxz9exyn5rx0807zvxfrvslrjqfchrd4d47kv9e0f46uedqtc');
+    const mockedAssetResponse = {
+      active: true,
+      active_epoch: 420,
+      amount: '2000000',
+      drep_id: 'drep15cfxz9exyn5rx0807zvxfrvslrjqfchrd4d47kv9e0f46uedqtc',
+      has_script: true,
+      hex: 'a61261172624e8333ceff098648d90f8e404e2e36d5b5f5985cbd35d'
+    } as Responses['drep'];
+
+    test('getDRepInfo', async () => {
+      mockResponses(request, [
+        [
+          `governance/dreps/${mockedDRepId}`,
+          {
+            ...mockedAssetResponse
+          }
+        ]
+      ]);
+
+      const response = await provider.getDRepInfo({ id: mockedDRepId });
+
+      expect(response).toMatchObject<DRepInfo>({
+        active: true,
+        activeEpoch: Cardano.EpochNo(420),
+        amount: 2_000_000n,
+        hasScript: true,
+        id: mockedDRepId
+      });
+    });
+  });
+});

packages/cardano-services-client/test/DRepProvider/BlockfrostDRepProvider.test.ts

@@ -60,3 +60,16 @@ export const getBobHandleProviderResponse = {
   policyId: Cardano.PolicyId('50fdcdbfa3154db86a87e4b5697ae30d272e0bbcfa8122efd3e301cb'),
   profilePic: Asset.Uri('ipfs://zrljm7nskakjydxlr450ktsj08zuw6aktvgfkmmyw9semrkrezryq3yd1')
 };
+
+export const mockResponses = (request: jest.Mock, responses: [string | RegExp, unknown][]) => {
+  request.mockImplementation(async (endpoint: string) => {
+    for (const [match, response] of responses) {
+      if (typeof match === 'string') {
+        if (match === endpoint) return response;
+      } else if (match.test(endpoint)) {
+        return response;
+      }
+    }
+    throw new Error(`Not implemented/matched: ${endpoint}`);
+  });
+};

packages/cardano-services-client/test/util.ts

@@ -91,7 +91,7 @@
     "wait-on": "^6.0.1"
   },
   "dependencies": {
-    "@blockfrost/blockfrost-js": "^5.5.0",
+    "@blockfrost/blockfrost-js": "^5.7.0",
     "@cardano-sdk/cardano-services-client": "workspace:~",
     "@cardano-sdk/core": "workspace:~",
     "@cardano-sdk/crypto": "workspace:~",

packages/cardano-services/package.json

@@ -1,17 +1,28 @@
-import { Address, AddressType } from './Address';
-import { OpaqueString, assertIsBech32WithPrefix, typedBech32 } from '@cardano-sdk/util';
+import * as BaseEncoding from '@scure/base';
+import { Address, AddressType, Credential, CredentialType } from './Address';
+import { Hash28ByteBase16 } from '@cardano-sdk/crypto';
+import { OpaqueString, typedBech32 } from '@cardano-sdk/util';
+
+const MAX_BECH32_LENGTH_LIMIT = 1023;
+const CIP_105_DREP_ID_LENGTH = 28;
+const CIP_129_DREP_ID_LENGTH = 29;
+
 /** DRepID as bech32 string */
 export type DRepID = OpaqueString<'DRepID'>;
 
-/**
- * @param {string} value DRepID as bech32 string
- * @throws InvalidStringError
- */
-export const DRepID = (value: string): DRepID => typedBech32(value, ['drep']);
+// CIP-105 is deprecated, however we still need to support it since several providers and tooling
+// stills uses this format.
+export const DRepID = (value: string): DRepID => {
+  try {
+    return typedBech32(value, ['drep'], 47);
+  } catch {
+    return typedBech32(value, ['drep', 'drep_script'], 45);
+  }
+};
 
 DRepID.isValid = (value: string): boolean => {
   try {
-    assertIsBech32WithPrefix(value, 'drep');
+    DRepID(value);
     return true;
   } catch {
     return false;
@@ -25,3 +36,73 @@ DRepID.canSign = (value: string): boolean => {
     return false;
   }
 };
+
+DRepID.cip105FromCredential = (credential: Credential): DRepID => {
+  let prefix = 'drep';
+  if (credential.type === CredentialType.ScriptHash) {
+    prefix = 'drep_script';
+  }
+
+  const words = BaseEncoding.bech32.toWords(Buffer.from(credential.hash, 'hex'));
+
+  return BaseEncoding.bech32.encode(prefix, words, MAX_BECH32_LENGTH_LIMIT) as DRepID;
+};
+
+DRepID.cip129FromCredential = (credential: Credential): DRepID => {
+  // The CIP-129 header is defined by 2 nibbles, where the first 4 bits represent the kind of governance credential
+  // (CC Hot, CC Cold and DRep), and the last 4 bits are the credential type (offset by 2 to ensure that governance
+  // identifiers remain distinct and are not inadvertently processed as addresses).
+  let header = '22'; // DRep-PubKeyHash header in hex [00100010]
+  if (credential.type === CredentialType.ScriptHash) {
+    header = '23'; // DRep-ScriptHash header in hex [00100011]
+  }
+
+  const cip129payload = `${header}${credential.hash}`;
+  const words = BaseEncoding.bech32.toWords(Buffer.from(cip129payload, 'hex'));
+
+  return BaseEncoding.bech32.encode('drep', words, MAX_BECH32_LENGTH_LIMIT) as DRepID;
+};
+
+DRepID.toCredential = (drepId: DRepID): Credential => {
+  const { words } = BaseEncoding.bech32.decode(drepId, MAX_BECH32_LENGTH_LIMIT);
+  const payload = BaseEncoding.bech32.fromWords(words);
+
+  if (payload.length !== CIP_105_DREP_ID_LENGTH && payload.length !== CIP_129_DREP_ID_LENGTH) {
+    throw new Error('Invalid DRepID payload');
+  }
+
+  if (payload.length === CIP_105_DREP_ID_LENGTH) {
+    const isScriptHash = drepId.includes('drep_script');
+
+    return {
+      hash: Hash28ByteBase16(Buffer.from(payload).toString('hex')),
+      type: isScriptHash ? CredentialType.ScriptHash : CredentialType.KeyHash
+    };
+  }
+
+  // CIP-129
+  const header = payload[0];
+  const hash = payload.slice(1);
+  const isDrepGovCred = (header & 0x20) === 0x20; // 0b00100000
+  const isScriptHash = (header & 0x03) === 0x03; // 0b00000011
+
+  if (!isDrepGovCred) {
+    throw new Error('Invalid governance credential type');
+  }
+
+  return {
+    hash: Hash28ByteBase16(Buffer.from(hash).toString('hex')),
+    type: isScriptHash ? CredentialType.ScriptHash : CredentialType.KeyHash
+  };
+};
+
+// Use these if you need to ensure the ID is in a specific format.
+DRepID.toCip105DRepID = (drepId: DRepID): DRepID => {
+  const credential = DRepID.toCredential(drepId);
+  return DRepID.cip105FromCredential(credential);
+};
+
+DRepID.toCip129DRepID = (drepId: DRepID): DRepID => {
+  const credential = DRepID.toCredential(drepId);
+  return DRepID.cip129FromCredential(credential);
+};

packages/core/src/Cardano/Address/DRepID.ts

@@ -0,0 +1 @@
+export * from './types';