feat: [LW-6471] Added optional metadata fetch feature from SMASH server
- node-ipc:/node-ipc
- ../../packages/e2e/local-network/scripts:/scripts
cardano-smash:
<<:
- *logging
- *with-postgres
depends_on:
cardano-db-sync:
condition: service_healthy
build:
context: ../../
dockerfile: compose/smash/Dockerfile
ports:
- ${SMASH_PORT:-3100}:3100
restart: on-failure
healthcheck:
test: [ 'CMD-SHELL', 'curl -s --fail http://localhost:3100/api/v1/status' ]
cardano-node-ogmios:
<<: *logging
healthcheck:
depends_on:
stake-pool-projector:
condition: service_healthy
cardano-smash:
condition: service_healthy
environment:
<<: *sdk-environment
API_URL: http://0.0.0.0:3003
QUEUES: ${QUEUES:-pool-metadata,pool-metrics}
STAKE_POOL_PROVIDER_URL: http://provider-server:3000/
METADATA_FETCH_MODE: ${METADATA_FETCH_MODE:-direct}
SMASH_URL: ${SMASH_URL:-http://cardano-smash:3100/api/v1}
healthcheck:
test: ['CMD-SHELL', 'curl -s --fail http://localhost:3003/v1.0.0/health']
ports:
smash-admin1,smash-password1
smash-admin2,smash-password2
ARG UBUNTU_VERSION=20.04
FROM ubuntu:${UBUNTU_VERSION}
ARG DBSYNC_BINARY_URL="https://update-cardano-mainnet.iohk.io/cardano-db-sync/cardano-db-sync-${CARDANO_DB_SYNC_VERSION:-13.1.0.0}-linux.tar.gz"
ENV NETWORK=${NETWORK:-"mainnet"}
RUN apt-get update && apt-get install curl -y
RUN curl ${DBSYNC_BINARY_URL} --output /tmp/dbsync-binary.tar.gz &&\
tar --extract --file /tmp/dbsync-binary.tar.gz --directory /bin ./cardano-smash-server &&\
rm /tmp/dbsync-binary.tar.gz
COPY packages/cardano-services/config/network/${NETWORK}/cardano-db-sync /config/
COPY compose/placeholder-secrets/smash-admins.txt /config/
COPY compose/smash/init.sh /bin
RUN chmod 755 /bin/init.sh
ENTRYPOINT ["init.sh"]
# Cardano JS SDK | Smash Server
Dockerized Cardano Smash Server based on Ubuntu. Downloads the Smash Server binary, configures and runs
it. `inputoutput/cardano-db-sync` image is not used since it doesn't contain Smash Server binary. This Docker image is intended for testing and development purposes only.
#!/bin/bash
DB=$(cat /run/secrets/postgres_db_db_sync)
PASSWORD=$(cat /run/secrets/postgres_password)
USER=$(cat /run/secrets/postgres_user)
echo "postgres:5432:${DB}:${USER}:${PASSWORD}" > /config/pgpass
_term() {
kill $CHILD
}
trap _term SIGTERM
PGPASSFILE=/config/pgpass cardano-smash-server \
--config /config/config.json \
--port 3100 \
--admins /config/smash-admins.txt &
CHILD=$!
wait "$CHILD"
METADATA_FETCH_MODE="smash"
SMASH_URL="http://cardano-smash:3100/api/v1"
HANDLE_POLICY_IDS=${HANDLE_POLICY_IDS:-f0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9a}
METADATA_FETCH_MODE="smash"
SMASH_URL="https://smash.cardano-mainnet.iohk.io/api/v1"
HANDLE_POLICY_IDS=${HANDLE_POLICY_IDS:-f0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9a}
OGMIOS_PORT=${OGMIOS_PORT:-1339}
METADATA_FETCH_MODE="smash"
SMASH_URL="http://cardano-smash:3100/api/v1"
OGMIOS_PORT=${OGMIOS_PORT:-1340}
METADATA_FETCH_MODE="smash"
SMASH_URL="http://cardano-smash:3100/api/v1"
# Cardano JS SDK | Docker Composer Environment Variables
This folder holds environment variable files for various Docker composer setups. The `.env` files are referenced in the `../package.json` file.
"cleanup:nm": "shx rm -rf node_modules",
"cleanup": "run-s cleanup:dist cleanup:nm",
"cli": "ts-node --transpile-only src/cli.ts",
"compose:up": "docker compose -p cardano-services-$NETWORK -f docker-compose.yml -f ../../compose/common.yml -f ../../compose/pg-agent.yml ${FILES:-} up",
"compose:up": "docker compose --env-file environments/.env.$NETWORK -p cardano-services-$NETWORK -f docker-compose.yml -f ../../compose/common.yml -f ../../compose/pg-agent.yml ${FILES:-} up",
"compose:down": "docker compose -p cardano-services-$NETWORK -f docker-compose.yml -f ../../compose/common.yml -f ../../compose/pg-agent.yml down -t 120",
"coverage": "yarn test --coverage",
"circular-deps:check": "madge --circular dist/cjs",
"lint": "eslint -c ../../complete.eslintrc.js \"src/**/*.ts\" \"test/**/*.ts\"",
"lint:fix": "yarn lint --fix",
"generate-migration": "typeorm-ts-node-commonjs migration:generate src/Projection/migrations/migrations -d src/migrationDataSource.ts",
"mainnet:dev": "FILES='-f ../../compose/dev.yml -f dev.yml' yarn mainnet:up",
"mainnet:up": "HANDLE_POLICY_IDS=${HANDLE_POLICY_IDS:-f0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9a} NETWORK=mainnet yarn compose:up",
"mainnet:up": "NETWORK=mainnet yarn compose:up",
"mainnet:down": "NETWORK=mainnet yarn compose:down",
"prepack": "yarn build",
"preprod:dev": "FILES='-f ../../compose/dev.yml -f dev.yml' yarn preprod:up",
"preprod:up": "HANDLE_POLICY_IDS=${HANDLE_POLICY_IDS:-f0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9a} NETWORK=preprod OGMIOS_PORT=${OGMIOS_PORT:-1339} yarn compose:up",
"preprod:up": "NETWORK=preprod yarn compose:up",
"preprod:down": "NETWORK=preprod yarn compose:down",
"pretest": "yarn build",
"preview:dev": "FILES='-f ../../compose/dev.yml -f dev.yml' yarn preview:up",
"preview:up": "NETWORK=preview OGMIOS_PORT=${OGMIOS_PORT:-1340} yarn compose:up",
"preview:up": "NETWORK=preview yarn compose:up",
"preview:down": "NETWORK=preview yarn compose:down",
"test": "jest --runInBand -c ./jest.config.js",
"test:build:verify": "tsc --build ./test",
import { Cardano } from '@cardano-sdk/core';
import { Cardano, NotImplementedError, ProviderError, ProviderFailure } from '@cardano-sdk/core';
import { CustomError } from 'ts-custom-error';
import { DataSource, MoreThan } from 'typeorm';
import { Hash32ByteBase16 } from '@cardano-sdk/crypto';
import { PoolMetadataEntity, PoolRegistrationEntity, StakePoolMetadataJob } from '@cardano-sdk/projection-typeorm';
import { StakePoolMetadataFetchMode, checkProgramOptions } from '../Program/options';
import { WorkerHandlerFactory } from './types';
import { createHttpStakePoolMetadataService } from '../StakePool';
import { isErrorWithConstraint } from './util';
}
};
export const getUrlToFetch = (
metadataFetchMode: StakePoolMetadataFetchMode,
smashUrl: string | undefined,
directUrl: string,
poolRegistrationId: string,
metadataHash: string
) => {
if (metadataFetchMode === StakePoolMetadataFetchMode.SMASH) {
return `${smashUrl}/metadata/${poolRegistrationId}/${metadataHash}`;
} else if (metadataFetchMode === StakePoolMetadataFetchMode.DIRECT) {
return directUrl;
}
throw new NotImplementedError(
`There is no implementation to handle the fetch mode (--metadata-fetch-mode): ${metadataFetchMode}`
);
};
export const attachExtendedMetadata = (
metadataWithoutExt: Cardano.StakePoolMetadata,
extMetadata: Cardano.ExtendedStakePoolMetadata | CustomError | undefined
): Cardano.StakePoolMetadata => {
if (extMetadata instanceof CustomError) {
const error = extMetadata;
if (error instanceof ProviderError && error.reason === ProviderFailure.NotFound) {
return { ...metadataWithoutExt!, ext: null };
}
return metadataWithoutExt;
} else if (extMetadata === undefined) {
return metadataWithoutExt;
}
return { ...metadataWithoutExt!, ext: extMetadata };
};
export const stakePoolMetadataHandlerFactory: WorkerHandlerFactory = (options) => {
const { dataSource, logger } = options;
const { dataSource, logger, metadataFetchMode, smashUrl } = options;
const service = createHttpStakePoolMetadataService(logger);
checkProgramOptions(metadataFetchMode, smashUrl);
return async (task: StakePoolMetadataJob) => {
const { metadataJson, poolId, poolRegistrationId } = task;
const { hash, url } = metadataJson;
return;
}
logger.info('Resolving stake pool metadata...', { poolId, poolRegistrationId });
const urlToFetch: string = getUrlToFetch(metadataFetchMode, smashUrl, url, poolId, hash);
logger.info('Resolving stake pool metadata...', { metadataFetchMode, poolId, poolRegistrationId });
const { errors, metadata } = await service.getStakePoolMetadata(hash, url);
const metadataResponse: Cardano.StakePoolMetadata | CustomError = await service.getStakePoolMetadata(
hash,
urlToFetch
);
logger.info('Stake pool metadata resolved', { errors, metadata, poolId, poolRegistrationId });
if (metadataResponse instanceof CustomError) {
logger.info('Stake pool metadata NOT resolved with errors', {
metadataResponse,
poolId,
poolRegistrationId,
url
});
// In case of errors the handler throws in order to let pg-boss to retry the job.
logger.info('StakePoolMetadataJob failed to fetch stake pool metadata.');
throw metadataResponse;
} else {
const metadataWithoutExt: Cardano.StakePoolMetadata = metadataResponse;
logger.info('Stake pool metadata resolved successfully', { metadataWithoutExt, poolId, poolRegistrationId, url });
logger.info('Resolving extended stake pool metadata...', { metadataFetchMode, poolId, poolRegistrationId });
const extendedMetadata = await service.getValidateStakePoolExtendedMetadata(metadataWithoutExt);
logger.info('Stake pool extended metadata resolved', {
extendedMetadata,
metadataFetchMode,
poolId,
poolRegistrationId
});
const metadata: Cardano.StakePoolMetadata = attachExtendedMetadata(metadataWithoutExt, extendedMetadata);
// In case there is some error in fetching extended metadata and the root metadata is populated,
// we need to save the latter anyway
if (metadata) {
logger.info('Saving stake pool metadata...');
await savePoolMetadata({ dataSource, hash, metadata, poolId, poolRegistrationId });
logger.info('Stake pool metadata saved');
}
// TODO: Store the error in a dedicated table
// Ref: LW-6409
logger.info('Stake pool metadata saved');
// In case of errors the handler throws in order to let pg-boss to retry the job.
if (errors?.length) throw errors[0];
if (extendedMetadata instanceof CustomError) {
logger.info('StakePoolMetadataJob failed to fetch extended stake pool metadata.');
throw extendedMetadata;
}
}
};
// TODO: Store the error in a dedicated table
// Ref: LW-6409
};
export * from './policyIds';
export * from './postgres';
export * from './rabbitMq';
export * from './stakePoolMetadata';
export * from './util';
import { Command } from 'commander';
import { MissingProgramOption } from '../errors';
import { STAKE_POOL_METADATA_QUEUE } from '@cardano-sdk/projection-typeorm';
import { URL } from 'url';
import { addOptions, newOption } from './util';
export enum StakePoolMetadataOptionDescriptions {
Mode = 'This mode governs where the stake pool metadata is fetched from',
Url = 'SMASH server api url'
}
export enum StakePoolMetadataFetchMode {
/**
* Use metadata available from the provided data by the projection. Projection reads its data directly from the certificate.
*/
DIRECT = 'direct',
/**
* Use configured SMASH server to fetch stake pool metadata.
*/
SMASH = 'smash'
}
export interface StakePoolMetadataProgramOptions {
smashUrl?: string;
metadataFetchMode: StakePoolMetadataFetchMode;
}
export const withStakePoolMetadataOptions = (command: Command) => {
addOptions(command, [
newOption(
'--metadata-fetch-mode <metadataFetchMode>',
StakePoolMetadataOptionDescriptions.Mode,
'METADATA_FETCH_MODE',
(mode: string) => StakePoolMetadataFetchMode[mode.toUpperCase() as keyof typeof StakePoolMetadataFetchMode],
'direct'
).choices(['direct', 'smash']),
newOption('--smash-url <smashUrl>', StakePoolMetadataOptionDescriptions.Url, 'SMASH_URL', (url) =>
new URL(url).toString()
)
]);
return command;
};
export const checkProgramOptions = (metadataFetchMode: StakePoolMetadataFetchMode, smashUrl: string | undefined) => {
if (!metadataFetchMode) throw new MissingProgramOption(STAKE_POOL_METADATA_QUEUE, 'medata-fetch-mode');
if (metadataFetchMode === StakePoolMetadataFetchMode.SMASH && !smashUrl)
throw new MissingProgramOption(
STAKE_POOL_METADATA_QUEUE,
`smash-url to be set when medata-fetch-mode is smash ${smashUrl}`
);
};
import { CommonProgramOptions, OgmiosProgramOptions, PosgresProgramOptions, RabbitMqProgramOptions } from '../options';
import {
CommonProgramOptions,
OgmiosProgramOptions,
PosgresProgramOptions,
RabbitMqProgramOptions,
StakePoolMetadataProgramOptions
} from '../options';
import { HandlePolicyIdsProgramOptions } from '../options/policyIds';
import { Milliseconds, Seconds } from '@cardano-sdk/core';
PosgresProgramOptions<'StakePool'> &
OgmiosProgramOptions &
HandlePolicyIdsProgramOptions &
RabbitMqProgramOptions & {
RabbitMqProgramOptions &
StakePoolMetadataProgramOptions & {
allowedOrigins?: string[];
cardanoNodeConfigPath?: string;
disableDbCache?: boolean;
import { PgBossQueue, queueHandlers } from '../../PgBoss';
import { Pool } from 'pg';
import { Router } from 'express';
import { StakePoolMetadataProgramOptions } from '../options/stakePoolMetadata';
import { contextLogger } from '@cardano-sdk/util';
import { createObservableDataSource } from '../../Projection/createTypeormProjection';
import { retryBackoff } from 'backoff-rxjs';
});
export type PgBossWorkerArgs = CommonProgramOptions &
StakePoolMetadataProgramOptions &
PosgresProgramOptions<'DbSync'> &
PosgresProgramOptions<'StakePool'> & {
parallelJobs: number;
/* eslint-disable max-depth */
import * as Crypto from '@cardano-sdk/crypto';
import { CML, Cardano } from '@cardano-sdk/core';
import { CML } from '@cardano-sdk/core';
import { CustomError } from 'ts-custom-error';
import { HexBlob } from '@cardano-sdk/util';
import { Logger } from 'ts-log';
throw error;
}
},
async getStakePoolMetadata(hash, url) {
const errors: CustomError[] = [];
let metadata: Cardano.StakePoolMetadata | undefined;
let extMetadata: Cardano.ExtendedStakePoolMetadata | undefined;
try {
logger.debug(`About to fetch stake pool metadata JSON from ${url}`);
// Verify base hashes
if (metadataHash !== hash) {
return {
errors: [
new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.InvalidStakePoolHash,
null,
`Invalid stake pool hash. Computed '${metadataHash}', expected '${hash}'`
)
],
metadata
};
return new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.InvalidStakePoolHash,
null,
`Invalid stake pool hash. Computed '${metadataHash}', expected '${hash}'`
);
}
// Transform fetched metadata from bytes array to JSON
metadata = JSON.parse(data.toString());
extMetadata = await this.validateStakePoolExtendedMetadata(errors, metadata);
return JSON.parse(data.toString());
} catch (error) {
if (axios.isAxiosError(error)) {
errors.push(
new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.FailedToFetchMetadata,
error.toJSON(),
`${SERVICE_NAME} failed to fetch metadata JSON from ${url} due to ${error.message}`
)
return new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.FailedToFetchMetadata,
error.toJSON(),
`${SERVICE_NAME} failed to fetch metadata JSON from ${url} due to ${error.message}`
);
} else if (error instanceof StakePoolMetadataServiceError) {
errors.push(error);
} else {
errors.push(
new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.Unknown,
JSON.stringify(error),
`${SERVICE_NAME} failed to fetch metadata JSON from ${url} due to ${
error instanceof Error ? error.message : 'unknown error'
}`
)
);
return error;
}
return new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.Unknown,
JSON.stringify(error),
`${SERVICE_NAME} failed to fetch metadata JSON from ${url} due to ${
error instanceof Error ? error.message : 'unknown error'
}`
);
}
return { errors, metadata: metadata ? { ...metadata, ext: extMetadata } : undefined };
},
async validateStakePoolExtendedMetadata(errors, metadata) {
async getValidateStakePoolExtendedMetadata(metadata) {
if (!metadata?.extDataUrl && !metadata?.extended) return;
// Validate CIP-6 ext metadata fields
if (metadata.extDataUrl && (!metadata.extSigUrl || !metadata.extVkey)) {
errors.push(
new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.InvalidMetadata,
null,
'Missing ext signature or public key'
)
return new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.InvalidMetadata,
null,
'Missing ext signature or public key'
);
return;
}
// Fetch extended metadata (supports both cip-6 and ada pools formats already)
let extMetadata: Cardano.ExtendedStakePoolMetadata | undefined = await this.getStakePoolExtendedMetadata(metadata);
// In case of CIP-6 standard -> perform signature verification
if (metadata.extDataUrl && metadata.extSigUrl && metadata.extVkey) {
// Based on the CIP-6, we have `extSigUrl` (A URL with the extended metadata signature), so we need to make another HTTP request to get the actual signature
try {
const signature = (await axiosClient.get<Crypto.Ed25519SignatureHex>(metadata.extSigUrl)).data;
const message = HexBlob.fromBytes(Buffer.from(JSON.stringify(extMetadata)));
const publicKey = Crypto.Ed25519PublicKeyHex(metadata.extVkey);
const bip32Ed25519 = new Crypto.CmlBip32Ed25519(CML);
// Verify the signature
const isSignatureValid = await bip32Ed25519.verify(signature, message, publicKey);
// If not valid -> omit extended metadata from response and add specific error
if (!isSignatureValid) {
extMetadata = undefined;
errors.push(
new StakePoolMetadataServiceError(
try {
const extMetadata = await this.getStakePoolExtendedMetadata(metadata);
// In case of CIP-6 standard -> perform signature verification
if (metadata.extDataUrl && metadata.extSigUrl && metadata.extVkey) {
// Based on the CIP-6, we have `extSigUrl` (A URL with the extended metadata signature), so we need to make another HTTP request to get the actual signature
try {
const signature = (await axiosClient.get<Crypto.Ed25519SignatureHex>(metadata.extSigUrl)).data;
const message = HexBlob.fromBytes(Buffer.from(JSON.stringify(extMetadata)));
const publicKey = Crypto.Ed25519PublicKeyHex(metadata.extVkey);
const bip32Ed25519 = new Crypto.CmlBip32Ed25519(CML);
// Verify the signature
const isSignatureValid = await bip32Ed25519.verify(signature, message, publicKey);
// If not valid -> omit extended metadata from response and add specific error
if (!isSignatureValid) {
return new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.InvalidExtendedMetadataSignature,
null,
'Invalid extended metadata signature'
)
);
}
);
}
// If signature url failed -> omit extended metadata from response and add specific error
} catch (error) {
extMetadata = undefined;
errors.push(
new StakePoolMetadataServiceError(
// If signature url failed -> omit extended metadata from response and add specific error
} catch (error) {
return new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.FailedToFetchExtendedSignature,
error,
`${SERVICE_NAME} failed to fetch extended signature from ${metadata.extSigUrl} due to connection error`
)
);
);
}
}
}
return extMetadata;
return extMetadata;
} catch (error) {
if (error instanceof CustomError) return error;
return new StakePoolMetadataServiceError(
StakePoolMetadataServiceFailure.Unknown,
JSON.stringify(error),
`${SERVICE_NAME} failed to get extended metadata due to ${
error instanceof Error ? error.message : 'unknown error'
}`
);
}
}
});
import { APExtMetadataResponse, Cip6ExtMetadataResponse, StakePoolMetadataResponse } from './HttpStakePoolMetadata';
import { APExtMetadataResponse, Cip6ExtMetadataResponse } from './HttpStakePoolMetadata';
import { Cardano } from '@cardano-sdk/core';
import { CustomError } from 'ts-custom-error';
import { Hash32ByteBase16 } from '@cardano-sdk/crypto';
export interface StakePoolMetadataService {
getStakePoolMetadata(hash: Hash32ByteBase16, url: string): Promise<StakePoolMetadataResponse>;
getStakePoolMetadata(hash: Hash32ByteBase16, url: string): Promise<Cardano.StakePoolMetadata | CustomError>;
getStakePoolExtendedMetadata(poolMetadata: Cardano.StakePoolMetadata): Promise<Cardano.ExtendedStakePoolMetadata>;
validateStakePoolExtendedMetadata(
errors: CustomError[],
metadata: Cardano.StakePoolMetadata | undefined
): Promise<Cardano.ExtendedStakePoolMetadata | undefined>;
getValidateStakePoolExtendedMetadata(
metadata: Cardano.StakePoolMetadata
): Promise<Cardano.ExtendedStakePoolMetadata | CustomError | undefined>;
}
export enum ExtMetadataFormat {
withHandlePolicyIdsOptions,
withOgmiosOptions,
withPostgresOptions,
withRabbitMqOptions
withRabbitMqOptions,
withStakePoolMetadataOptions
} from './Program';
import { Command } from 'commander';
import { DB_CACHE_TTL_DEFAULT } from './InMemoryCache';
const pgBoss = program.command('start-pg-boss-worker').description('Start the pg-boss worker');
addOptions(withCommonOptions(withPostgresOptions(pgBoss, ['DbSync', 'StakePool']), PG_BOSS_WORKER_API_URL_DEFAULT), [
newOption(
'--parallel-jobs <parallelJobs>',
PgBossWorkerOptionDescriptions.ParallelJobs,
'PARALLEL_JOBS',
(parallelJobs) => Number.parseInt(parallelJobs, 10),
PARALLEL_JOBS_DEFAULT
addOptions(
withCommonOptions(
withStakePoolMetadataOptions(withPostgresOptions(pgBoss, ['DbSync', 'StakePool'])),
PG_BOSS_WORKER_API_URL_DEFAULT
),
newOption('--queues <queues>', PgBossWorkerOptionDescriptions.Queues, 'QUEUES', (queues) => {
const queuesArray = queues.split(',') as PgBossQueue[];
[
newOption(
'--parallel-jobs <parallelJobs>',
PgBossWorkerOptionDescriptions.ParallelJobs,
'PARALLEL_JOBS',
(parallelJobs) => Number.parseInt(parallelJobs, 10),
PARALLEL_JOBS_DEFAULT
),
newOption('--queues <queues>', PgBossWorkerOptionDescriptions.Queues, 'QUEUES', (queues) => {
const queuesArray = queues.split(',') as PgBossQueue[];
for (const queue of queuesArray) if (!isValidQueue(queue)) throw new Error(`Unknown queue name: '${queue}'`);
for (const queue of queuesArray) if (!isValidQueue(queue)) throw new Error(`Unknown queue name: '${queue}'`);
return queuesArray;
}).makeOptionMandatory()
]).action(async (args: PgBossWorkerArgs) =>
return queuesArray;
}).makeOptionMandatory()
]
).action(async (args: PgBossWorkerArgs) =>
runServer('pg-boss worker', () =>
loadPgBossWorker({
...args,
import { Cardano } from '@cardano-sdk/core';
import * as handler from '../../src/PgBoss';
import { Cardano, NotImplementedError, ProviderError, ProviderFailure } from '@cardano-sdk/core';
import { DataMocks } from '../data-mocks';
import { DataSource } from 'typeorm';
import { Hash32ByteBase16 } from '@cardano-sdk/crypto';
import { PoolMetadataEntity, PoolRegistrationEntity } from '@cardano-sdk/projection-typeorm';
import { StakePoolMetadataFetchMode } from '../../src/Program/options';
import { initHandlerTest, poolId } from './util';
import { isUpdateOutdated, savePoolMetadata } from '../../src/PgBoss';
describe('stakePoolMetadataHandler', () => {
const rewardAccount = 'test_addr';
describe('isUpdateOutdated', () => {
it('returns true if there is a newer pool update', async () => {
expect(await isUpdateOutdated(dataSource, poolId, '23')).toBe(true);
expect(await handler.isUpdateOutdated(dataSource, poolId, '23')).toBe(true);
});
it('returns false if there are no newer pool updates', async () => {
expect(await isUpdateOutdated(dataSource, poolId, '42')).toBe(false);
expect(await handler.isUpdateOutdated(dataSource, poolId, '42')).toBe(false);
});
});
expect(await metadataRepos.find({ where: { poolUpdate } })).toEqual([]);
// Insert
await savePoolMetadata({ dataSource, hash, metadata, poolId, poolRegistrationId });
await handler.savePoolMetadata({ dataSource, hash, metadata, poolId, poolRegistrationId });
// One record was inserted
const insertResult = await metadataRepos.find({ where: { poolUpdate } });
expect(insertResult).toEqual([{ description, ext, hash, homepage, id: insertResult[0].id, name, ticker }]);
// Update
metadata.name = 'updated';
await savePoolMetadata({ dataSource, hash, metadata, poolId, poolRegistrationId });
await handler.savePoolMetadata({ dataSource, hash, metadata, poolId, poolRegistrationId });
// One record updated and no records inserted
const updateResult = await metadataRepos.find({ where: { poolUpdate } });
expect(await metadataRepos.find({ where: { poolUpdate } })).toEqual([]);
// Failing insert attempt
await savePoolMetadata({ dataSource, hash, metadata, poolId, poolRegistrationId });
await handler.savePoolMetadata({ dataSource, hash, metadata, poolId, poolRegistrationId });
// No records was inserted
// No records were inserted
expect(await metadataRepos.find({ where: { poolUpdate } })).toEqual([]);
});
});
describe('attachExtendedMetadata', () => {
const metadata = {
description: 'description',
homepage: 'homepage',
name: 'name',
ticker: 'ticker'
} as Cardano.StakePoolMetadata;
it('attaches full extended metadata', async () => {
const expectedExtendedMetadata = DataMocks.Pool.adaPoolExtendedMetadata;
const attachedMetadata = handler.attachExtendedMetadata(metadata, expectedExtendedMetadata);
expect(attachedMetadata).not.toBeNull();
expect(attachedMetadata).toEqual({ ...metadata, ext: expectedExtendedMetadata });
});
it('does not modify the base metadata if an extended metadata reference does not exist', async () => {
const expectedExtendedMetadata = undefined;
const attachedMetadata = handler.attachExtendedMetadata(metadata, expectedExtendedMetadata);
expect(attachedMetadata).not.toBeNull();
expect(attachedMetadata).toEqual(metadata);
});
it('attaches extended metadata as undefined if a connection failure occurs', async () => {
const error = new ProviderError(ProviderFailure.ConnectionFailure);
const expectedExtendedMetadata = undefined;
const attachedMetadata = handler.attachExtendedMetadata(metadata, error);
expect(attachedMetadata).not.toBeNull();
expect(attachedMetadata).toEqual({ ...metadata, ext: expectedExtendedMetadata });
});
it('attaches extended metadata as null if the pool metadata is not found', async () => {
const error = new ProviderError(ProviderFailure.NotFound);
const expectedExtendedMetadata = null;
const attachedMetadata = handler.attachExtendedMetadata(metadata, error);
expect(attachedMetadata).not.toBeNull();
expect(attachedMetadata).toEqual({ ...metadata, ext: expectedExtendedMetadata });
});
});
describe('getUrlToFetch', () => {
it('returns correct url in mode StakePoolMetadataFetchMode.DIRECT', async () => {
const expectedUrl = 'happy_url';
const generatedUrl = handler.getUrlToFetch(
StakePoolMetadataFetchMode.DIRECT,
'not_relevant',
expectedUrl,
'not_relevant',
'not_relevant'
);
expect(generatedUrl).toEqual(expectedUrl);
});
it('returns correct url in node StakePoolMetadataFetchMode.SMASH', async () => {
const smashUrl = 'http://localhost:3100';
const poolRegistrationId = 'pool_registration_id';
const metadataHash = 'metadata_hash';
const expectedUrl = `${smashUrl}/metadata/${poolRegistrationId}/${metadataHash}`;
const generatedUrl = handler.getUrlToFetch(
StakePoolMetadataFetchMode.SMASH,
smashUrl,
'not_relevant',
poolRegistrationId,
metadataHash
);
expect(generatedUrl).toEqual(expectedUrl);
});
it('throws NotImplementedError if an unhandled fetch mode is supplied', async () => {
const smashUrl = 'http://localhost:3100';
const poolRegistrationId = 'pool_registration_id';
const metadataHash = 'metadata_hash';
expect(() =>
handler.getUrlToFetch(
StakePoolMetadataFetchMode['not_a_fetch_mode' as keyof typeof StakePoolMetadataFetchMode],
smashUrl,
'not_relevant',
poolRegistrationId,
metadataHash
)
).toThrowError(NotImplementedError);
});
});
});
# Description Adding fund 11 dates The idea scale importer sql file will be updated in another ticket Fixes https://github.com/input-output-hk/catalyst-core/issues/639 ## Type of change Please delete options that are not relevant. - [ ] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) - [ ] This change requires a documentation update ## How Has This Been Tested? Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration - [ ] Test A - [ ] Test B **Test Configuration**: _if applicable_ - Firmware version: - Hardware: - Toolchain: - SDK: **List of new dependencies**: _if applicable_ Provide a list of newly added dependencies in this PR, with the description of what are they doing and why do we need them. - Crate A: description - Crate B: description ## Checklist - [ ] My code follows the style guidelines of this project - [ ] I have performed a self-review of my code - [ ] I have commented my code, particularly in hard-to-understand areas - [ ] I have made corresponding changes to the documentation - [ ] My changes generate no new warnings - [ ] I have added tests that prove my fix is effective or that my feature works - [ ] New and existing unit tests pass locally with my changes - [ ] Any dependent changes have been merged and published in downstream modules
LW-9237 typeorm stake pool provider backward compatibility
As we removed those guards from the chain layer, it is important that the logic layer is doing this filtering.
It looks like the author mean to do:
if(parser.peek() == UNSIGNED_INT) { parser.readUInt() }
instead of
if(parser.peek() == UNSIGNED_INT) { parser.readInt() }
Fix FF build
To prevent aborting the wrong Head `headId` was added to the `OnAbortTx`. Logic layer now aborts the head that is seen as initialized.
The flaky test picked up this error
# Conflicts: # package.json
