refactor: improve string type safety

packages/blockfrost/src/BlockfrostToCore.ts

@@ -58,7 +58,7 @@ export const BlockfrostToCore = {
   transactionUtxos: (utxoResponse: Responses['tx_content_utxo']) => ({
     inputs: utxoResponse.inputs.map((input) => ({
       ...BlockfrostToCore.txIn(input),
-      address: input.address
+      address: Cardano.Address(input.address)
     })),
     outputs: utxoResponse.outputs.map(BlockfrostToCore.txOut)
   }),
@@ -70,9 +70,9 @@ export const BlockfrostToCore = {
   }),
 
   txIn: (blockfrost: BlockfrostInput): Cardano.TxIn => ({
-    address: blockfrost.address,
+    address: Cardano.Address(blockfrost.address),
     index: blockfrost.output_index,
-    txId: blockfrost.tx_hash
+    txId: Cardano.TransactionId(blockfrost.tx_hash)
   }),
 
   txOut: (blockfrost: BlockfrostOutput): Cardano.TxOut => {
@@ -82,7 +82,7 @@ export const BlockfrostToCore = {
       assets[amount.unit] = BigInt(amount.quantity);
     }
     return {
-      address: blockfrost.address,
+      address: Cardano.Address(blockfrost.address),
       value: {
         assets,
         coins: BigInt(blockfrost.amount.find(({ unit }) => unit === 'lovelace')!.quantity)

packages/blockfrost/src/blockfrostAssetProvider.ts

@@ -34,7 +34,7 @@ export const blockfrostAssetProvider = (options: Options): AssetProvider => {
         response.map(({ action, amount, tx_hash }) => ({
           action: action === 'minted' ? Cardano.AssetProvisioning.Mint : Cardano.AssetProvisioning.Burn,
           quantity: BigInt(amount),
-          transactionId: tx_hash
+          transactionId: Cardano.TransactionId(tx_hash)
         }))
     });
 
@@ -47,7 +47,13 @@ export const blockfrostAssetProvider = (options: Options): AssetProvider => {
       fingerprint: response.fingerprint,
       history:
         response.mint_or_burn_count === 1
-          ? [{ action: Cardano.AssetProvisioning.Mint, quantity, transactionId: response.initial_mint_tx_hash }]
+          ? [
+              {
+                action: Cardano.AssetProvisioning.Mint,
+                quantity,
+                transactionId: Cardano.TransactionId(response.initial_mint_tx_hash)
+              }
+            ]
           : await getAssetHistory(assetId),
       metadata: mapMetadata(response.onchain_metadata, response.metadata),
       name,

packages/blockfrost/src/blockfrostWalletProvider.ts

@@ -102,18 +102,18 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
       addresses.map(async (address) =>
         fetchByAddressSequentially<Cardano.Utxo, BlockfrostUtxo>({
           address,
-          request: (addr: Cardano.Address, pagination) => blockfrost.addressesUtxos(addr, pagination),
+          request: (addr: Cardano.Address, pagination) => blockfrost.addressesUtxos(addr.toString(), pagination),
           responseTranslator: (addr: Cardano.Address, response: Responses['address_utxo_content']) =>
-            BlockfrostToCore.addressUtxoContent(addr, response)
+            BlockfrostToCore.addressUtxoContent(addr.toString(), response)
         })
       )
     );
     const utxo = utxoResults.flat(1);
     if (rewardAccount !== undefined) {
       try {
-        const accountResponse = await blockfrost.accounts(rewardAccount);
+        const accountResponse = await blockfrost.accounts(rewardAccount.toString());
         const delegationAndRewards = {
-          delegate: accountResponse.pool_id || undefined,
+          delegate: accountResponse.pool_id ? Cardano.PoolId(accountResponse.pool_id) : undefined,
           rewards: BigInt(accountResponse.withdrawable_amount)
         };
         return { delegationAndRewards, utxo };
@@ -165,7 +165,7 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
     return response.map(
       ({ address, amount }): Cardano.Withdrawal => ({
         quantity: BigInt(amount),
-        stakeAddress: address
+        stakeAddress: Cardano.RewardAccount(address)
       })
     );
   };
@@ -183,7 +183,7 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
     return response.map(({ pool_id, retiring_epoch }) => ({
       __typename: Cardano.CertificateType.PoolRetirement,
       epoch: retiring_epoch,
-      poolId: pool_id
+      poolId: Cardano.PoolId(pool_id)
     }));
   };
 
@@ -192,7 +192,7 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
     return response.map(({ pool_id, active_epoch }) => ({
       __typename: Cardano.CertificateType.PoolRegistration,
       epoch: active_epoch,
-      poolId: pool_id,
+      poolId: Cardano.PoolId(pool_id),
       poolParameters: ((): Cardano.PoolParameters => {
         logger.warn('Omitting poolParameters for certificate in tx', hash);
         return null as unknown as Cardano.PoolParameters;
@@ -204,7 +204,7 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
     const response = await blockfrost.txsMirs(hash);
     return response.map(({ address, amount, cert_index, pot }) => ({
       __typename: Cardano.CertificateType.MIR,
-      address,
+      address: Cardano.Address(address),
       certIndex: cert_index,
       pot,
       quantity: BigInt(amount)
@@ -217,20 +217,20 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
       __typename: registration
         ? Cardano.CertificateType.StakeKeyRegistration
         : Cardano.CertificateType.StakeKeyDeregistration,
-      address,
-      certIndex: cert_index
+      certIndex: cert_index,
+      rewardAccount: Cardano.RewardAccount(address)
     }));
   };
 
   const fetchDelegationCerts = async (hash: string): Promise<Cardano.StakeDelegationCertificate[]> => {
     const response = await blockfrost.txsDelegations(hash);
     return response.map(({ cert_index, index, address, active_epoch, pool_id }) => ({
       __typename: Cardano.CertificateType.StakeDelegation,
-      address,
       certIndex: cert_index,
       delegationIndex: index,
       epoch: active_epoch,
-      poolId: pool_id
+      poolId: Cardano.PoolId(pool_id),
+      rewardAccount: Cardano.RewardAccount(address)
     }));
   };
 
@@ -252,9 +252,9 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
     ];
   };
 
-  const fetchJsonMetadata = async (txHash: Cardano.Hash16): Promise<Cardano.MetadatumMap | null> => {
+  const fetchJsonMetadata = async (txHash: Cardano.TransactionId): Promise<Cardano.MetadatumMap | null> => {
     try {
-      const response = await blockfrost.txsMetadata(txHash);
+      const response = await blockfrost.txsMetadata(txHash.toString());
       return response.reduce((map, metadatum) => {
         // Not sure if types are correct, missing 'label', but it's present in docs
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -273,9 +273,9 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
 
   // eslint-disable-next-line unicorn/consistent-function-scoping
   const parseValidityInterval = (num: string | null) => Number.parseInt(num || '') || undefined;
-  const fetchTransaction = async (hash: string): Promise<Cardano.TxAlonzo> => {
-    const { inputs, outputs } = BlockfrostToCore.transactionUtxos(await blockfrost.txsUtxos(hash));
-    const response = await blockfrost.txs(hash);
+  const fetchTransaction = async (hash: Cardano.TransactionId): Promise<Cardano.TxAlonzo> => {
+    const { inputs, outputs } = BlockfrostToCore.transactionUtxos(await blockfrost.txsUtxos(hash.toString()));
+    const response = await blockfrost.txs(hash.toString());
     const metadata = await fetchJsonMetadata(hash);
     return {
       auxiliaryData: metadata
@@ -284,7 +284,7 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
           }
         : undefined,
       blockHeader: {
-        blockHash: response.block,
+        blockHash: Cardano.BlockId(response.block),
         blockHeight: response.block_height,
         slot: response.slot
       },
@@ -325,14 +325,14 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
           BlockfrostTransactionContent
         >({
           address,
-          request: (addr: Cardano.Address, pagination) => blockfrost.addressesTransactions(addr, pagination)
+          request: (addr: Cardano.Address, pagination) => blockfrost.addressesTransactions(addr.toString(), pagination)
         })
       )
     );
 
     const transactionsArray = await Promise.all(
       addressTransactions.map((transactionArray) =>
-        queryTransactionsByHashes(transactionArray.map(({ tx_hash }) => tx_hash))
+        queryTransactionsByHashes(transactionArray.map(({ tx_hash }) => Cardano.TransactionId(tx_hash)))
       )
     );
 
@@ -348,15 +348,15 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
   };
 
   const accountRewards = async (
-    stakeAddress: Cardano.Address,
+    stakeAddress: Cardano.RewardAccount,
     { lowerBound = 0, upperBound = Number.MAX_SAFE_INTEGER }: EpochRange = {}
   ): Promise<EpochRewards[]> => {
     const result: EpochRewards[] = [];
     const batchSize = 100;
     let page = 1;
     let haveMorePages = true;
     while (haveMorePages) {
-      const rewards = await blockfrost.accountsRewards(stakeAddress, { count: batchSize, page });
+      const rewards = await blockfrost.accountsRewards(stakeAddress.toString(), { count: batchSize, page });
       result.push(
         ...rewards
           .filter(({ epoch }) => lowerBound <= epoch && epoch <= upperBound)
@@ -397,7 +397,7 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
   };
 
   const queryBlocksByHashes: WalletProvider['queryBlocksByHashes'] = async (hashes) => {
-    const responses = await Promise.all(hashes.map((hash) => blockfrost.blocks(hash)));
+    const responses = await Promise.all(hashes.map((hash) => blockfrost.blocks(hash.toString())));
     return responses.map((response) => {
       if (!response.epoch || !response.epoch_slot || !response.height || !response.slot || !response.block_vrf) {
         throw new ProviderError(ProviderFailure.Unknown, null, 'Queried unsupported block');
@@ -409,14 +409,14 @@ export const blockfrostWalletProvider = (options: Options, logger = dummyLogger)
         epochSlot: response.epoch_slot,
         fees: BigInt(response.fees || '0'),
         header: {
-          blockHash: response.hash,
+          blockHash: Cardano.BlockId(response.hash),
           blockHeight: response.height,
           slot: response.slot
         },
-        nextBlock: response.next_block || undefined,
-        previousBlock: response.previous_block || undefined,
+        nextBlock: response.next_block ? Cardano.BlockId(response.next_block) : undefined,
+        previousBlock: response.previous_block ? Cardano.BlockId(response.previous_block) : undefined,
         size: response.size,
-        slotLeader: response.slot_leader,
+        slotLeader: Cardano.PoolId(response.slot_leader),
         totalOutput: BigInt(response.output || '0'),
         txCount: response.tx_count,
         vrf: response.block_vrf

packages/blockfrost/src/util.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Error as BlockfrostError } from '@blockfrost/blockfrost-js';
+import { InvalidStringError, ProviderError, ProviderFailure } from '@cardano-sdk/core';
 import { PaginationOptions } from '@blockfrost/blockfrost-js/lib/types';
-import { ProviderError, ProviderFailure } from '@cardano-sdk/core';
 
 export const formatBlockfrostError = (error: unknown) => {
   const blockfrostError = error as BlockfrostError;
@@ -11,6 +11,9 @@ export const formatBlockfrostError = (error: unknown) => {
   if (typeof blockfrostError !== 'object') {
     throw new ProviderError(ProviderFailure.Unknown, error, 'failed to parse error (response type)');
   }
+  if (error instanceof InvalidStringError) {
+    throw new ProviderError(ProviderFailure.InvalidResponse, error);
+  }
   const errorAsType1 = blockfrostError as {
     status_code: number;
     message: string;

packages/blockfrost/test/blockfrostAssetProvider.test.ts

@@ -46,7 +46,7 @@ describe('blockfrostAssetProvider', () => {
           {
             action: Cardano.AssetProvisioning.Mint,
             quantity: 12_000n,
-            transactionId: '6804edf9712d2b619edb6ac86861fe93a730693183a262b165fcc1ba1bc99cad'
+            transactionId: Cardano.TransactionId('6804edf9712d2b619edb6ac86861fe93a730693183a262b165fcc1ba1bc99cad')
           }
         ],
         metadata: {
@@ -72,12 +72,12 @@ describe('blockfrostAssetProvider', () => {
         {
           action: 'minted',
           amount: '13000',
-          tx_hash: 'tx1hash'
+          tx_hash: '4123d70f66414cc921f6ffc29a899aafc7137a99a0fd453d6b200863ef5702d6'
         },
         {
           action: 'burned',
           amount: '1000',
-          tx_hash: 'tx2hash'
+          tx_hash: '01d7366549986d83edeea262e97b68eca3430d3bb052ed1c37d2202fd5458872'
         }
       ] as Responses['asset_history']);
 
@@ -91,12 +91,12 @@ describe('blockfrostAssetProvider', () => {
           {
             action: Cardano.AssetProvisioning.Mint,
             quantity: 13_000n,
-            transactionId: 'tx1hash'
+            transactionId: Cardano.TransactionId('4123d70f66414cc921f6ffc29a899aafc7137a99a0fd453d6b200863ef5702d6')
           },
           {
             action: Cardano.AssetProvisioning.Burn,
             quantity: 1000n,
-            transactionId: 'tx2hash'
+            transactionId: Cardano.TransactionId('01d7366549986d83edeea262e97b68eca3430d3bb052ed1c37d2202fd5458872')
           }
         ],
         metadata: {