Merge remote-tracking branch 'origin/master' into nightly

packages/cardano-services/package.json

@@ -49,7 +49,7 @@
     "lint:fix": "yarn lint --fix",
     "mainnet:dev": "DOCKER_BUILDKIT=1 COMPOSE_DOCKER_CLI_BUILD=1 docker compose -p cardano-services-mainnet -f docker-compose.yml -f docker-compose-dev.yml up",
     "mainnet:up": "DOCKER_BUILDKIT=1 COMPOSE_DOCKER_CLI_BUILD=1 docker compose -p cardano-services-mainnet up",
-    "mainnet:down": "docker compose -p cardano-services-mainnet down",
+    "mainnet:down": "docker compose -p cardano-services-mainnet down -t 30",
     "prepack": "yarn build",
     "preprod:dev": "DOCKER_BUILDKIT=1 COMPOSE_DOCKER_CLI_BUILD=1 OGMIOS_PORT=${OGMIOS_PORT:-1339} NETWORK=preprod docker compose -p cardano-services-preprod -f docker-compose.yml -f docker-compose-dev.yml up",
     "preprod:up": "DOCKER_BUILDKIT=1 COMPOSE_DOCKER_CLI_BUILD=1 OGMIOS_PORT=${OGMIOS_PORT:-1339} NETWORK=preprod docker compose -p cardano-services-preprod up",

packages/cardano-services/src/Program/options/postgres.ts

@@ -13,6 +13,7 @@ export enum PostgresOptionDescriptions {
   SslCaFile = 'PostgreSQL SSL CA file path',
   Host = 'PostgreSQL host',
   Port = 'PostgreSQL port',
+  PoolMax = 'Maximum number of clients in the PostgreSQL pool',
   ServiceDiscoveryArgs = 'Postgres SRV service name, db, user and password'
 }
 
@@ -26,6 +27,7 @@ export interface PosgresProgramOptions {
   postgresPassword?: string;
   postgresPasswordFile?: string;
   postgresHost?: string;
+  postgresPoolMax?: number;
   postgresPort?: string;
   postgresSslCaFile?: string;
 }
@@ -82,6 +84,11 @@ export const withPostgresOptions = (command: Command) =>
         .argParser(existingFileValidator)
     )
     .addOption(new Option('--postgres-host <postgresHost>', PostgresOptionDescriptions.Host).env('POSTGRES_HOST'))
+    .addOption(
+      new Option('--postgres-pool-max <postgresPoolMax>', PostgresOptionDescriptions.PoolMax)
+        .env('POSTGRES_POOL_MAX')
+        .argParser((max) => Number.parseInt(max, 10))
+    )
     .addOption(new Option('--postgres-port <postgresPort>', PostgresOptionDescriptions.Port).env('POSTGRES_PORT'))
     .addOption(
       new Option('--postgres-ssl-ca-file <postgresSslCaFile>', PostgresOptionDescriptions.SslCaFile).env(

packages/cardano-services/src/Program/services/postgres.ts

@@ -2,9 +2,9 @@
 /* eslint-disable promise/no-nesting */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable unicorn/no-nested-ternary */
-import { ClientConfig, Pool, QueryConfig } from 'pg';
 import { DnsResolver } from '../utils';
 import { Logger } from 'ts-log';
+import { Pool, PoolConfig, QueryConfig } from 'pg';
 import { PosgresProgramOptions } from '../options';
 import { URL } from 'url';
 import { isConnectionError } from '@cardano-sdk/util';
@@ -23,10 +23,10 @@ import fs from 'fs';
 export const getPoolWithServiceDiscovery = async (
   dnsResolver: DnsResolver,
   logger: Logger,
-  { host, database, password, ssl, user }: ClientConfig
+  { host, database, max, password, ssl, user }: PoolConfig
 ): Promise<Pool> => {
   const { name, port } = await dnsResolver(host!);
-  let pool = new Pool({ database, host: name, password, port, ssl, user });
+  let pool = new Pool({ database, host: name, max, password, port, ssl, user });
 
   return new Proxy<Pool>({} as Pool, {
     get(_, prop) {
@@ -37,7 +37,7 @@ export const getPoolWithServiceDiscovery = async (
             if (isConnectionError(error)) {
               const record = await dnsResolver(host!);
               logger.info(`DNS resolution for Postgres service, resolved with record: ${JSON.stringify(record)}`);
-              pool = new Pool({ database, host: record.name, password, port: record.port, ssl, user });
+              pool = new Pool({ database, host: record.name, max, password, port: record.port, ssl, user });
               return await pool.query(args, values);
             }
             throw error;
@@ -60,11 +60,13 @@ export const getPool = async (
   options?: PosgresProgramOptions
 ): Promise<Pool | undefined> => {
   const ssl = options?.postgresSslCaFile ? { ca: loadSecret(options.postgresSslCaFile) } : undefined;
-  if (options?.postgresConnectionString) return new Pool({ connectionString: options.postgresConnectionString, ssl });
+  if (options?.postgresConnectionString)
+    return new Pool({ connectionString: options.postgresConnectionString, max: options.postgresPoolMax, ssl });
   if (options?.postgresSrvServiceName && options.postgresUser && options.postgresDb && options.postgresPassword) {
     return getPoolWithServiceDiscovery(dnsResolver, logger, {
       database: options.postgresDb,
       host: options.postgresSrvServiceName,
+      max: options.postgresPoolMax,
       password: options.postgresPassword,
       ssl,
       user: options.postgresUser

packages/cardano-services/test/cli.test.ts

@@ -683,6 +683,8 @@ describe('CLI', () => {
                   postgresPassword,
                   '--postgres-host',
                   postgresHost,
+                  '--postgres-pool-max',
+                  '50',
                   '--postgres-port',
                   postgresPort,
                   ServiceNames.Utxo
@@ -705,6 +707,7 @@ describe('CLI', () => {
                   POSTGRES_DB: postgresDb,
                   POSTGRES_HOST: postgresHost,
                   POSTGRES_PASSWORD: postgresPassword,
+                  POSTGRES_POOL_MAX: '50',
                   POSTGRES_PORT: postgresPort,
                   POSTGRES_USER: postgresUser,
                   SERVICE_NAMES: ServiceNames.Utxo

packages/core/src/Asset/util/assetId.ts

@@ -1,27 +1,10 @@
 import { AssetId, AssetName, PolicyId } from '../../Cardano/types/Asset';
-import { CML } from '../../CML/CML';
-import { bytesToHex } from '../../util/misc/bytesToHex';
 
 export const policyIdFromAssetId = (assetId: AssetId): PolicyId => PolicyId(assetId.slice(0, 56));
 export const assetNameFromAssetId = (assetId: AssetId): AssetName => AssetName(assetId.slice(56));
 
-/**
- * @returns {string} concatenated hex-encoded policy id and asset name
- */
-export const createAssetId = (scriptHash: CML.ScriptHash, assetName: CML.AssetName): AssetId =>
-  AssetId(bytesToHex(scriptHash.to_bytes()) + bytesToHex(assetName.name()));
-
 /**
  * @returns {AssetId} concatenated policy id and asset name
  */
 export const assetIdFromPolicyAndName = (policyId: PolicyId, assetName: AssetName): AssetId =>
   AssetId(policyId + assetName);
-
-export const parseAssetId = (assetId: AssetId) => {
-  const policyId = policyIdFromAssetId(assetId);
-  const assetName = assetNameFromAssetId(assetId);
-  return {
-    assetName: CML.AssetName.new(Buffer.from(assetName, 'hex')),
-    scriptHash: CML.ScriptHash.from_bytes(Buffer.from(policyId, 'hex'))
-  };
-};

packages/core/src/CML/cmlToCore/cmlToCore.ts

@@ -1,14 +1,19 @@
 import * as Cardano from '../../Cardano';
 import * as Crypto from '@cardano-sdk/crypto';
+import { AssetId, PlutusLanguageVersion, ScriptType } from '../../Cardano';
 import { Base64Blob, HexBlob, ManagedFreeableScope, usingAutoFree } from '@cardano-sdk/util';
 import { CML } from '../CML';
-import { PlutusLanguageVersion, ScriptType } from '../../Cardano';
 import { ScriptKind } from '@dcspark/cardano-multiplatform-lib-nodejs';
 import { SerializationError, SerializationFailure } from '../../errors';
 import { bytesToHex } from '../../util/misc';
-import { createAssetId } from '../../Asset/util';
 import { createCertificate } from './certificate';
 
+/**
+ * @returns {string} concatenated hex-encoded policy id and asset name
+ */
+export const createAssetId = (scriptHash: CML.ScriptHash, assetName: CML.AssetName): AssetId =>
+  AssetId(bytesToHex(scriptHash.to_bytes()) + bytesToHex(assetName.name()));
+
 export const txRequiredExtraSignatures = (
   signatures: CML.Ed25519KeyHashes | undefined
 ): Crypto.Ed25519KeyHashHex[] | undefined =>

packages/core/src/CML/coreToCml/coreToCml.ts

@@ -65,11 +65,20 @@ import {
 } from '@dcspark/cardano-multiplatform-lib-nodejs';
 
 import * as certificate from './certificate';
+import { AssetId, RedeemerPurpose } from '../../Cardano';
 import { CML } from '../CML';
 import { ManagedFreeableScope } from '@cardano-sdk/util';
-import { RedeemerPurpose } from '../../Cardano';
 import { SerializationError, SerializationFailure } from '../../errors';
-import { assetNameFromAssetId, parseAssetId, policyIdFromAssetId } from '../../Asset/util';
+import { assetNameFromAssetId, policyIdFromAssetId } from '../../Asset/util';
+
+export const parseAssetId = (assetId: AssetId) => {
+  const policyId = policyIdFromAssetId(assetId);
+  const assetName = assetNameFromAssetId(assetId);
+  return {
+    assetName: CML.AssetName.new(Buffer.from(assetName, 'hex')),
+    scriptHash: CML.ScriptHash.from_bytes(Buffer.from(policyId, 'hex'))
+  };
+};
 
 export const tokenMap = (scope: ManagedFreeableScope, map: Cardano.TokenMap) => {
   const multiasset = scope.manage(MultiAsset.new());

packages/core/test/Asset/util/assetId.test.ts

@@ -1,23 +1,8 @@
 import { AssetId } from '../../../src/Cardano';
-import {
-  assetIdFromPolicyAndName,
-  assetNameFromAssetId,
-  createAssetId,
-  parseAssetId,
-  policyIdFromAssetId
-} from '../../../src/Asset/util';
+import { assetIdFromPolicyAndName, assetNameFromAssetId, policyIdFromAssetId } from '../../../src/Asset/util';
 
 describe('Asset', () => {
   describe('util', () => {
-    it('createAssetId and parseAssetId', async () => {
-      const assetId = AssetId('659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba8254534c41');
-      const tsla = parseAssetId(assetId);
-      expect(new TextDecoder().decode(tsla.assetName.name())).toEqual('TSLA');
-      expect(Buffer.from(tsla.scriptHash.to_bytes()).toString('hex')).toEqual(
-        '659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba82'
-      );
-      expect(createAssetId(tsla.scriptHash, tsla.assetName)).toEqual(assetId);
-    });
     it('policyIdFromAssetId, assetNameFromAssetId and assetIdFromPolicyAndName', async () => {
       const assetId = AssetId('659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba8254534c41');
       const [policyId, assetName] = [policyIdFromAssetId(assetId), assetNameFromAssetId(assetId)];

packages/core/test/CML/cmlToCore.test.ts

@@ -1,4 +1,5 @@
 import * as Crypto from '@cardano-sdk/crypto';
+import { AssetId } from '../../src/Cardano';
 import { Base64Blob, HexBlob, ManagedFreeableScope } from '@cardano-sdk/util';
 import { Cardano, cmlToCore, coreToCml } from '../../src';
 import { NativeScript } from '@dcspark/cardano-multiplatform-lib-nodejs';
@@ -17,6 +18,8 @@ import {
   valueCoinOnly,
   valueWithAssets
 } from './testData';
+import { createAssetId } from '../../src/CML/cmlToCore';
+import { parseAssetId } from '../../src/CML/coreToCml';
 
 describe('cmlToCore', () => {
   let scope: ManagedFreeableScope;
@@ -28,6 +31,16 @@ describe('cmlToCore', () => {
   afterEach(() => {
     scope.dispose();
   });
+
+  describe('AssetId', () => {
+    it('createAssetId', async () => {
+      const assetId = AssetId('659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba8254534c41');
+      const cmlAssetId = parseAssetId(assetId);
+
+      expect(createAssetId(cmlAssetId.scriptHash, cmlAssetId.assetName)).toEqual(assetId);
+    });
+  });
+
   describe('value', () => {
     it('coin only', () => {
       expect(cmlToCore.value(coreToCml.value(scope, valueCoinOnly))).toEqual(valueCoinOnly);

packages/core/test/CML/coreToCml.test.ts

@@ -1,6 +1,7 @@
 /* eslint-disable max-len */
-import { Asset, CML, Cardano, SerializationFailure, coreToCml } from '../../src';
+import { AssetId } from '../../src/Cardano';
 import { BigNum } from '@dcspark/cardano-multiplatform-lib-nodejs';
+import { CML, Cardano, SerializationFailure, coreToCml } from '../../src';
 import { ManagedFreeableScope } from '@cardano-sdk/util';
 import {
   babbageTxBody,
@@ -19,6 +20,7 @@ import {
   valueWithAssets,
   vkey
 } from './testData';
+import { parseAssetId } from '../../src/CML/coreToCml';
 
 const txOutByron = {
   ...txOut,
@@ -38,9 +40,22 @@ describe('coreToCml', () => {
     scope.dispose();
   });
 
+  describe('AssetId', () => {
+    it('parseAssetId', async () => {
+      const assetId = AssetId('659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba8254534c41');
+      const cmlAssetId = parseAssetId(assetId);
+
+      expect(new TextDecoder().decode(cmlAssetId.assetName.name())).toEqual('TSLA');
+      expect(Buffer.from(cmlAssetId.scriptHash.to_bytes()).toString('hex')).toEqual(
+        '659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba82'
+      );
+    });
+  });
+
   it('txIn', () => {
     expect(coreToCml.txIn(scope, txIn)).toBeInstanceOf(CML.TransactionInput);
   });
+
   describe('txOut', () => {
     it('converts to CML.TransactionOutput', () => {
       expect(coreToCml.txOut(scope, txOut)).toBeInstanceOf(CML.TransactionOutput);
@@ -80,7 +95,7 @@ describe('coreToCml', () => {
       const multiasset = scope.manage(value.multiasset())!;
       expect(multiasset.len()).toBe(3);
       for (const [assetId, expectedAssetQuantity] of valueWithAssets.assets!.entries()) {
-        const { scriptHash, assetName } = Asset.util.parseAssetId(assetId);
+        const { scriptHash, assetName } = parseAssetId(assetId);
         const multiAsset = scope.manage(multiasset.get(scriptHash)!);
         const assetQuantity = BigInt(scope.manage(multiAsset.get(assetName)!).to_str());
         expect(assetQuantity).toBe(expectedAssetQuantity);
@@ -95,7 +110,7 @@ describe('coreToCml', () => {
       const scriptHashes = scope.manage(multiasset.keys());
       expect(scriptHashes.len()).toBe(3);
       for (const [assetId, expectedAssetQuantity] of txOut.value.assets!.entries()) {
-        const { scriptHash, assetName } = Asset.util.parseAssetId(assetId);
+        const { scriptHash, assetName } = parseAssetId(assetId);
         const multiAsset = scope.manage(multiasset.get(scriptHash)!);
         const assetQuantity = BigInt(scope.manage(multiAsset.get(assetName)!).to_str());
         expect(assetQuantity).toBe(expectedAssetQuantity);