Merge pull request #1005 from input-output-hk/feat/lw-9128-conway-era-compatible-sdk-clients

Feat/lw 9128 conway era compatible sdk clients

Author: iccicci

compose/common.yml

@@ -66,7 +66,7 @@ x-provider-server-environment: &provider-server-environment
   SERVICE_NAMES: ${SERVICE_NAMES:-asset,chain-history,handle,network-info,rewards,stake-pool,tx-submit,utxo}
   SUBMIT_API_URL: ${SUBMIT_API_URL:-http://cardano-submit-api:8090/}
   USE_BLOCKFROST: ${USE_BLOCKFROST:-false}
-  USE_SUBMIT_API: ${USE_SUBMIT_API:-true}
+  USE_SUBMIT_API: ${USE_SUBMIT_API:-false}
 
 x-sdk-environment: &sdk-environment
   LOGGER_MIN_SEVERITY: ${LOGGER_MIN_SEVERITY:-info}

packages/cardano-services-client/src/TxSubmitProvider/TxSubmitApiProvider.ts

@@ -1,6 +1,7 @@
 import { Cardano, ProviderError, ProviderFailure, SubmitTxArgs, TxBodyCBOR, TxSubmitProvider } from '@cardano-sdk/core';
 import { Logger } from 'ts-log';
 import { hexStringToBuffer } from '@cardano-sdk/util';
+import { mapCardanoTxSubmitError } from './cardanoTxSubmitErrorMapper';
 import axios, { AxiosInstance } from 'axios';
 
 export class TxSubmitApiProvider implements TxSubmitProvider {
@@ -42,7 +43,7 @@ export class TxSubmitApiProvider implements TxSubmitProvider {
 
         if (typeof status === 'number' && status >= 400 && status < 500) this.#healthStatus = true;
 
-        throw new ProviderError(ProviderFailure.BadRequest, null, data as string);
+        throw new ProviderError(ProviderFailure.BadRequest, mapCardanoTxSubmitError(data), data as string);
       }
 
       throw new ProviderError(ProviderFailure.Unknown, error, 'submitting tx');

packages/cardano-services-client/src/TxSubmitProvider/cardanoTxSubmitErrorMapper.ts

@@ -0,0 +1,20 @@
+/* eslint-disable wrap-regex */
+import { TxSubmissionError, TxSubmissionErrorCode } from '@cardano-sdk/core';
+
+export const mapCardanoTxSubmitError = (errorData: unknown): TxSubmissionError | null => {
+  if (typeof errorData === 'string') {
+    if (/outsideofvalidity/i.test(errorData)) {
+      return new TxSubmissionError(TxSubmissionErrorCode.OutsideOfValidityInterval, null, errorData);
+    }
+    if (/valuenotconserved/i.test(errorData)) {
+      return new TxSubmissionError(TxSubmissionErrorCode.ValueNotConserved, null, errorData);
+    }
+    if (/nonadacollateral/i.test(errorData)) {
+      return new TxSubmissionError(TxSubmissionErrorCode.NonAdaCollateral, null, errorData);
+    }
+    if (/incompletewithdrawals/i.test(errorData)) {
+      return new TxSubmissionError(TxSubmissionErrorCode.IncompleteWithdrawals, null, errorData);
+    }
+  }
+  return null;
+};

packages/cardano-services-client/src/TxSubmitProvider/txSubmitHttpProvider.ts

@@ -1,11 +1,16 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import {
-  CardanoNodeErrors,
+  CardanoNodeUtil,
+  GeneralCardanoNodeError,
+  GeneralCardanoNodeErrorCode,
   HandleOwnerChangeError,
   HttpProviderConfigPaths,
   ProviderError,
   ProviderFailure,
-  TxSubmitProvider
+  TxSubmissionError,
+  TxSubmissionErrorCode,
+  TxSubmitProvider,
+  reasonToProviderFailure
 } from '@cardano-sdk/core';
 import { CreateHttpProviderConfig, createHttpProvider } from '../HttpProvider';
 import { apiVersion } from '../version';
@@ -17,25 +22,43 @@ const paths: HttpProviderConfigPaths<TxSubmitProvider> = {
   submitTx: '/submit'
 };
 
-const toTxSubmissionError = (error: any): CardanoNodeErrors.TxSubmissionError | null => {
-  if (typeof error === 'object' && typeof error?.name === 'string' && typeof error?.message === 'string') {
-    const rawError = error as CardanoNodeErrors.TxSubmissionError;
+/**
+ * Takes an unknown error param.
+ * Returns an instance of TxSubmissionError or GeneralCardanoNodeError from the error if the error
+ * is an object, with an undefined or valid TxSubmissionError or GeneralCardanoNodeError code, and
+ * a string message.
+ * Returns null otherwise.
+ */
+const toTxSubmissionError = (error: any): TxSubmissionError | GeneralCardanoNodeError | null => {
+  if (typeof error === 'object' && error !== null && typeof error?.message === 'string') {
+    if (CardanoNodeUtil.isTxSubmissionErrorCode(error.code)) {
+      return Object.setPrototypeOf(error, TxSubmissionError.prototype);
+    }
 
-    const txSubmissionErrorName = rawError.name as keyof typeof CardanoNodeErrors.TxSubmissionErrors;
-    const ErrorClass = CardanoNodeErrors.TxSubmissionErrors[txSubmissionErrorName];
-    if (ErrorClass) {
-      Object.setPrototypeOf(error, ErrorClass.prototype);
-      return error;
+    if (CardanoNodeUtil.isGeneralCardanoNodeErrorCode(error.code)) {
+      return error instanceof GeneralCardanoNodeError
+        ? error
+        : new GeneralCardanoNodeError(error.code, error.data || null, error.message);
     }
-    if (rawError.name === CardanoNodeErrors.UnknownTxSubmissionError.name) {
-      Object.setPrototypeOf(error, CardanoNodeErrors.UnknownTxSubmissionError.prototype);
-      return error;
+
+    if (error.code === undefined || error.code === null) {
+      return new GeneralCardanoNodeError(GeneralCardanoNodeErrorCode.Unknown, error?.data || null, error.message);
     }
-    return new CardanoNodeErrors.UnknownTxSubmissionError(error);
   }
   return null;
 };
 
+const codeToProviderFailure = (code: GeneralCardanoNodeErrorCode | TxSubmissionErrorCode) => {
+  switch (code) {
+    case GeneralCardanoNodeErrorCode.Unknown:
+      return ProviderFailure.Unknown;
+    case GeneralCardanoNodeErrorCode.ServerNotReady:
+      return ProviderFailure.ServerUnavailable;
+    default:
+      return ProviderFailure.BadRequest;
+  }
+};
+
 /**
  * Connect to a Cardano Services HttpServer instance with the service available
  *
@@ -55,19 +78,20 @@ export const txSubmitHttpProvider = (config: CreateHttpProviderConfig<TxSubmitPr
         }
         case 'submitTx': {
           if (typeof error === 'object' && typeof error.innerError === 'object') {
+            // Ogmios errors have inner error. Parse that to get the real error
             const txSubmissionError = toTxSubmissionError(error.innerError);
             if (txSubmissionError) {
-              const failure =
-                txSubmissionError instanceof CardanoNodeErrors.UnknownTxSubmissionError
-                  ? ProviderFailure.Unknown
-                  : ProviderFailure.BadRequest;
-              throw new ProviderError(failure, txSubmissionError);
+              throw new ProviderError(codeToProviderFailure(txSubmissionError.code), txSubmissionError);
             }
 
             if (error.name === 'HandleOwnerChangeError') {
               Object.setPrototypeOf(error, HandleOwnerChangeError);
             }
           }
+          // No inner error. Use the outer reason to determine the error type.
+          if (error.reason && typeof error.reason === 'string') {
+            throw new ProviderError(reasonToProviderFailure(error.reason), error);
+          }
         }
       }
       throw new ProviderError(ProviderFailure.Unknown, error);

packages/cardano-services-client/test/TxSubmitProvider/cardanoTxSubmitErrorMapper.test.ts

@@ -0,0 +1,31 @@
+import { CardanoNodeUtil, TxSubmissionErrorCode } from '@cardano-sdk/core';
+import { mapCardanoTxSubmitError } from '../../src/TxSubmitProvider/cardanoTxSubmitErrorMapper';
+
+describe('mapCardanoTxSubmitError', () => {
+  describe('stringish errors', () => {
+    it('can map OutsideOfValidityIntervalError to TxSubmissionErrorCode.OutsideOfValidityInterval', () => {
+      const errorData = 'blah blah OutsideOfValidity blah blah';
+      expect(CardanoNodeUtil.isOutsideOfValidityIntervalError(mapCardanoTxSubmitError(errorData))).toBeTruthy();
+    });
+
+    it('can map ValueNotConservedError to TxSubmissionErrorCode.ValueNotConserved', () => {
+      const errorData = 'blah blah ValueNotConserved blah blah';
+      expect(CardanoNodeUtil.isValueNotConservedError(mapCardanoTxSubmitError(errorData))).toBeTruthy();
+    });
+
+    it('can map NonAdaCollateralError to TxSubmissionErrorCode.NonAdaCollateral', () => {
+      const errorData = 'blah blah NonAdaCollateral blah blah';
+      expect(mapCardanoTxSubmitError(errorData)?.code).toEqual(TxSubmissionErrorCode.NonAdaCollateral);
+    });
+
+    it('can map IncompleteWithdrawalsError to TxSubmissionErrorCode.IncompleteWithdrawals', () => {
+      const errorData = 'blah blah IncompleteWithdrawals blah blah';
+      expect(CardanoNodeUtil.isIncompleteWithdrawalsError(mapCardanoTxSubmitError(errorData))).toBeTruthy();
+    });
+
+    it('returns null for unknown errors', () => {
+      const errorData = 'blah blah unknown blah blah';
+      expect(mapCardanoTxSubmitError(errorData)).toBeNull();
+    });
+  });
+});

packages/cardano-services-client/test/TxSubmitProvider/txSubmitHttpProvider.test.ts

@@ -1,4 +1,11 @@
-import { CardanoNodeErrors, ProviderError, ProviderFailure } from '@cardano-sdk/core';
+import {
+  GeneralCardanoNodeError,
+  GeneralCardanoNodeErrorCode,
+  ProviderError,
+  ProviderFailure,
+  TxSubmissionError,
+  TxSubmissionErrorCode
+} from '@cardano-sdk/core';
 import { bufferToHexString } from '@cardano-sdk/util';
 import { config } from '../util';
 import { handleProviderMocks } from '@cardano-sdk/util-dev';
@@ -53,19 +60,24 @@ describe('txSubmitHttpProvider', () => {
 
       describe('errors', () => {
         const testError =
-          (bodyError: Error, providerFailure: ProviderFailure, providerErrorType: unknown) => async () => {
+          (
+            bodyError: Error | null,
+            providerFailure: ProviderFailure,
+            providerErrorType: unknown,
+            reason?: ProviderFailure
+          ) =>
+          async () => {
             try {
               axiosMock.onPost().replyOnce(() => {
-                throw handleProviderMocks.axiosError(bodyError);
+                throw handleProviderMocks.axiosError(bodyError, reason);
               });
               const provider = txSubmitHttpProvider(config);
               await provider.submitTx({ signedTransaction: emptyUintArrayAsHexString });
               throw new Error('Expected to throw');
             } catch (error) {
               if (error instanceof ProviderError) {
                 expect(error.reason).toBe(providerFailure);
-                const innerError = error.innerError as CardanoNodeErrors.TxSubmissionError;
-                expect(innerError).toBeInstanceOf(providerErrorType);
+                expect(error.innerError).toBeInstanceOf(providerErrorType);
               } else {
                 throw new TypeError('Expected ProviderError');
               }
@@ -75,30 +87,42 @@ describe('txSubmitHttpProvider', () => {
         it(
           'rehydrates errors',
           testError(
-            new CardanoNodeErrors.TxSubmissionErrors.BadInputsError({ badInputs: [] }),
+            new TxSubmissionError(TxSubmissionErrorCode.EmptyInputSet, null, ''),
             ProviderFailure.BadRequest,
-            CardanoNodeErrors.TxSubmissionErrors.BadInputsError
+            TxSubmissionError
           )
         );
 
         it(
           'maps unrecognized errors to UnknownTxSubmissionError',
-          testError(new Error('Unknown error'), ProviderFailure.Unknown, CardanoNodeErrors.UnknownTxSubmissionError)
+          testError(new Error('Unknown error'), ProviderFailure.Unknown, GeneralCardanoNodeError)
+        );
+
+        it(
+          'uses reason to determine ProviderFailure type when innerError is missing',
+          testError(null, ProviderFailure.BadRequest, ProviderError)
+        );
+
+        it(
+          'non-providerError reason is mapped to ProviderFailure.Unknown when innerError is missing',
+          testError(null, ProviderFailure.Unknown, ProviderError, 'invalidReason' as ProviderFailure)
         );
 
         it('does not re-wrap UnknownTxSubmissionError', async () => {
           expect.assertions(3);
           axiosMock.onPost().replyOnce(() => {
-            throw handleProviderMocks.axiosError(new CardanoNodeErrors.UnknownTxSubmissionError('Unknown error'));
+            throw handleProviderMocks.axiosError(
+              new GeneralCardanoNodeError(GeneralCardanoNodeErrorCode.Unknown, null, '')
+            );
           });
           const provider = txSubmitHttpProvider(config);
           try {
             await provider.submitTx({ signedTransaction: emptyUintArrayAsHexString });
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
           } catch (error: any) {
             expect(error).toBeInstanceOf(ProviderError);
-            expect(error.innerError).toBeInstanceOf(CardanoNodeErrors.UnknownTxSubmissionError);
-            expect(error.innerError.innerError.name).not.toBe(CardanoNodeErrors.UnknownTxSubmissionError.name);
+            expect(error.innerError).toBeInstanceOf(GeneralCardanoNodeError);
+            expect(error.innerError.innerError).toBeUndefined();
           }
         });
       });

packages/cardano-services/src/TxSubmit/TxSubmitHttpService.ts

@@ -1,5 +1,5 @@
 import {
-  Cardano,
+  CardanoNodeUtil,
   ProviderError,
   ProviderFailure,
   TxSubmitProvider,
@@ -47,7 +47,7 @@ export class TxSubmitHttpService extends HttpService {
           if (!isHealthy) {
             return HttpServer.sendJSON(res, new ProviderError(ProviderFailure.Unhealthy, firstError), 503);
           }
-          if (Cardano.util.asTxSubmissionError(error)) {
+          if (CardanoNodeUtil.asTxSubmissionError(error)) {
             return HttpServer.sendJSON(res, new ProviderError(ProviderFailure.BadRequest, firstError), 400);
           }
           return HttpServer.sendJSON(res, new ProviderError(ProviderFailure.Unknown, firstError), 500);

packages/cardano-services/test/TxSubmit/TxSubmitHttpService.test.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { APPLICATION_JSON, CONTENT_TYPE, HttpServer, HttpServerConfig, TxSubmitHttpService } from '../../src';
-import { CardanoNodeErrors, ProviderError, TxSubmitProvider } from '@cardano-sdk/core';
 import { CreateHttpProviderConfig, txSubmitHttpProvider } from '@cardano-sdk/cardano-services-client';
 import { FATAL, createLogger } from 'bunyan';
 import { OgmiosTxSubmitProvider } from '@cardano-sdk/ogmios';
+import { ProviderError, TxSubmissionError, TxSubmissionErrorCode, TxSubmitProvider } from '@cardano-sdk/core';
 import { bufferToHexString, fromSerializableObject } from '@cardano-sdk/util';
 import { getPort } from 'get-port-please';
 import { logger } from '@cardano-sdk/util-dev';
@@ -172,7 +172,13 @@ describe('TxSubmitHttpService', () => {
 
   describe('healthy but failing submission', () => {
     describe('/submit', () => {
-      const stubErrors = [new CardanoNodeErrors.TxSubmissionErrors.BadInputsError({ badInputs: [] })];
+      const stubErrors = [
+        new TxSubmissionError(
+          TxSubmissionErrorCode.NonEmptyRewardAccount,
+          { nonEmptyRewardAccountBalance: { lovelace: 10n } },
+          'Bad inputs'
+        )
+      ];
 
       beforeAll(async () => {
         txSubmitProvider = txSubmitProviderMock(
@@ -193,14 +199,15 @@ describe('TxSubmitHttpService', () => {
       });
 
       it('rehydrates errors when used with TxSubmitHttpProvider', async () => {
-        expect.assertions(2);
+        expect.assertions(3);
         const clientProvider = txSubmitHttpProvider(clientConfig);
         try {
           await clientProvider.submitTx({ signedTransaction: emptyUintArrayAsHexString });
         } catch (error: any) {
           if (error instanceof ProviderError) {
-            const innerError = error.innerError as CardanoNodeErrors.TxSubmissionError;
-            expect(innerError).toBeInstanceOf(CardanoNodeErrors.TxSubmissionErrors.BadInputsError);
+            const innerError = error.innerError as TxSubmissionError;
+            expect(innerError).toBeInstanceOf(TxSubmissionError);
+            expect(innerError.code).toBe(stubErrors[0].code);
             expect(innerError.message).toBe(stubErrors[0].message);
           }
         }

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

@@ -27,7 +27,9 @@ export enum CertificateType {
   ResignCommitteeCold = 'ResignCommitteeColdCertificate',
   RegisterDelegateRepresentative = 'RegisterDelegateRepresentativeCertificate',
   UnregisterDelegateRepresentative = 'UnregisterDelegateRepresentativeCertificate',
-  UpdateDelegateRepresentative = 'UpdateDelegateRepresentativeCertificate'
+  UpdateDelegateRepresentative = 'UpdateDelegateRepresentativeCertificate',
+  RegisterCcHotKey = 'RegisterCcHotKeyCertificate',
+  RetireCc = 'RetireCcCertificate'
 }
 
 // Conway Certificates
@@ -106,6 +108,14 @@ export interface UpdateDelegateRepresentativeCertificate {
   anchor: Anchor | null;
 }
 
+export interface RegisterCcHotKeyCertificate {
+  __typename: CertificateType.RegisterCcHotKey;
+}
+
+export interface RetireCcCertificate {
+  __typename: CertificateType.RetireCc;
+}
+
 /** To be deprecated in the Era after conway replaced by <NewStakeAddressCertificate> */
 export interface StakeAddressCertificate {
   __typename: CertificateType.StakeRegistration | CertificateType.StakeDeregistration;
@@ -173,7 +183,9 @@ export type Certificate =
   | ResignCommitteeColdCertificate
   | RegisterDelegateRepresentativeCertificate
   | UnRegisterDelegateRepresentativeCertificate
-  | UpdateDelegateRepresentativeCertificate;
+  | UpdateDelegateRepresentativeCertificate
+  | RegisterCcHotKeyCertificate
+  | RetireCcCertificate;
 
 /**
  * Creates a stake key registration certificate from a given reward account.