@layerzerolabs/common-canton 1.2.69 → 1.2.71

package/src/client/grpc.ts

@@ -1,441 +0,0 @@
-import {
-    AddTransactionsRequest,
-    Enums_TopologyChangeOp,
-    GenerateTransactionsRequest,
-    GenerateTransactionsRequest_Proposal,
-    ListDecentralizedNamespaceDefinitionRequest,
-    ListNamespaceDelegationRequest,
-    ListPartyToKeyMappingRequest,
-    ListPartyToParticipantRequest,
-    type SignedTopologyTransaction,
-    TopologyManagerReadServiceClient,
-    TopologyManagerWriteServiceClient,
-    type TopologyMapping,
-} from '@canton-network/core-ledger-proto';
-import { GrpcTransport } from '@protobuf-ts/grpc-transport';
-
-import type { TokenProvider } from '../auth/token-provider';
-import { CantonError, CantonProtocolError } from '../errors';
-import {
-    buildDecentralizedNamespaceDefinitionMapping,
-    buildNamespaceDelegationMapping,
-    buildPartyToKeyMapping,
-    buildPartyToParticipantMapping,
-} from './topology/mappings';
-import { SynchronizerConnectivityServiceClient } from './topology/synchronizer-connectivity';
-import type {
-    CantonGrpcClientOptions,
-    CreateDecentralizedNamespaceDefinitionTxParams,
-    CreateNamespaceDelegationTxParams,
-    CreatePartyToKeyMappingTxParams,
-    CreatePartyToParticipantMappingTxParams,
-    DecentralizedNamespaceDefinitionState,
-    GeneratedTopologyTransaction,
-    NamespaceDelegationState,
-    PartyToKeyMappingState,
-    PartyToParticipantMappingState,
-    UpdateDecentralizedNamespaceDefinitionTxParams,
-} from './topology/types';
-import {
-    buildChannelCredentials,
-    computeDecentralizedNamespace,
-    headStateBaseQuery,
-    synchronizerStore,
-} from './topology/utils';
-import { computePublicKeyFingerprint } from './utils';
-
-/** Default gRPC client options: 128 MiB message-size limits for large admin responses. */
-const DEFAULT_GRPC_CLIENT_OPTIONS = {
-    'grpc.max_receive_message_length': 128 * 1024 * 1024,
-    'grpc.max_send_message_length': 128 * 1024 * 1024,
-} as const;
-
-/**
- * gRPC client for the Canton participant admin Topology Manager API.
- *
- * Exposes read queries for topology mappings and write helpers that call
- * `GenerateTransactions` to produce unsigned topology transactions and
- * `AddTransactions` to submit signed ones.
- *
- * A fresh Bearer token is attached to each RPC via {@link TokenProvider}.
- */
-export class CantonGrpcClient {
-    readonly #transport: GrpcTransport;
-    readonly #topologyRead: TopologyManagerReadServiceClient;
-    readonly #topologyWrite: TopologyManagerWriteServiceClient;
-    readonly #connectivity: SynchronizerConnectivityServiceClient;
-    readonly #tokenProvider: TokenProvider;
-    #synchronizerId?: string;
-
-    /**
-     * @param opts - Admin API host, auth, optional synchronizer id, and transport security.
-     */
-    constructor(opts: CantonGrpcClientOptions) {
-        this.#tokenProvider = opts.tokenProvider;
-        this.#synchronizerId = opts.synchronizerId;
-        this.#transport = new GrpcTransport({
-            host: opts.host,
-            channelCredentials: buildChannelCredentials(opts.host, opts.insecureTransport),
-            clientOptions: opts.grpcClientOptions ?? DEFAULT_GRPC_CLIENT_OPTIONS,
-        });
-        this.#topologyRead = new TopologyManagerReadServiceClient(this.#transport);
-        this.#topologyWrite = new TopologyManagerWriteServiceClient(this.#transport);
-        this.#connectivity = new SynchronizerConnectivityServiceClient(this.#transport);
-    }
-
-    /** Returns per-RPC gRPC metadata with a fresh Bearer token. */
-    async #getMeta(): Promise<Record<string, string>> {
-        const token = await this.#tokenProvider.getToken();
-        return { Authorization: `Bearer ${token}` };
-    }
-
-    /**
-     * Returns the client synchronizer id, discovering it on first use when omitted at construction.
-     *
-     * @throws {CantonProtocolError} If the participant exposes no synchronizer store.
-     */
-    async #getSynchronizerId(): Promise<string> {
-        if (this.#synchronizerId) {
-            return this.#synchronizerId;
-        }
-        this.#synchronizerId = await this.#discoverSynchronizerId();
-        return this.#synchronizerId;
-    }
-
-    /**
-     * Resolves the logical id of the first synchronizer the participant is connected to.
-     *
-     * @throws {CantonProtocolError} If the participant is not connected to any synchronizer.
-     */
-    async #discoverSynchronizerId(): Promise<string> {
-        const { response } = await this.#connectivity.listConnectedSynchronizers(
-            {},
-            { meta: await this.#getMeta() },
-        );
-        for (const synchronizer of response.connectedSynchronizers) {
-            if (synchronizer.synchronizerId) {
-                return synchronizer.synchronizerId;
-            }
-        }
-        throw new CantonProtocolError('Participant is not connected to any synchronizer');
-    }
-
-    /**
-     * Calls `GenerateTransactions` for a single ADD_REPLACE mapping.
-     *
-     * @param synchronizerId - Synchronizer store to target.
-     * @param mapping - Topology mapping to encode into the transaction.
-     * @param serial - Topology serial (`0` lets Canton auto-determine).
-     * @returns Unsigned topology transaction (`serializedTransaction`, `transactionHash`).
-     * @throws {CantonProtocolError} If the RPC returns no generated transaction.
-     */
-    async #generateTopologyTransaction(
-        synchronizerId: string,
-        mapping: TopologyMapping,
-        serial: number,
-    ): Promise<GeneratedTopologyTransaction> {
-        const { response } = await this.#topologyWrite.generateTransactions(
-            GenerateTransactionsRequest.create({
-                proposals: [
-                    GenerateTransactionsRequest_Proposal.create({
-                        operation: Enums_TopologyChangeOp.ADD_REPLACE,
-                        serial,
-                        mapping,
-                        store: synchronizerStore(synchronizerId),
-                    }),
-                ],
-            }),
-            { meta: await this.#getMeta() },
-        );
-
-        const generated = response.generatedTransactions[0];
-
-        if (!generated) {
-            throw new CantonProtocolError('GenerateTransactions returned no topology transaction');
-        }
-
-        return generated;
-    }
-
-    /**
-     * Lists Namespace Delegation (NSD) mappings for a namespace.
-     *
-     * Queries topology head state on the synchronizer. Returns every result from
-     * the list RPC.
-     *
-     * @param namespaceFingerprint - Namespace to filter on (for root NSD, the owner key fingerprint).
-     * @returns All matching NSD mappings, or an empty array if none exist.
-     */
-    async getNamespaceDelegation(
-        namespaceFingerprint: string,
-    ): Promise<NamespaceDelegationState[]> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const { response } = await this.#topologyRead.listNamespaceDelegation(
-            ListNamespaceDelegationRequest.create({
-                baseQuery: headStateBaseQuery(synchronizerId),
-                filterNamespace: namespaceFingerprint,
-                // Empty string = no target-key filter; return all delegations for this namespace.
-                filterTargetKeyFingerprint: '',
-            }),
-            { meta: await this.#getMeta() },
-        );
-
-        return response.results.flatMap((result) => {
-            const item = result.item;
-            const publicKey = item?.targetKey?.publicKey;
-            if (!item || !publicKey) {
-                return [];
-            }
-            return [
-                {
-                    namespace: item.namespace,
-                    targetKeyFingerprint: computePublicKeyFingerprint(publicKey),
-                    isRootDelegation: item.isRootDelegation,
-                    serial: result.context?.serial ?? 0,
-                },
-            ];
-        });
-    }
-
-    /**
-     * Lists Decentralized Namespace Definition (DND) mappings for a namespace.
-     *
-     * Queries topology head state on the synchronizer. For a party id `hint::1220…`,
-     * pass the `1220…` suffix as `namespaceFingerprint`.
-     *
-     * @param namespaceFingerprint - Decentralized namespace fingerprint to filter on.
-     * @returns All matching DND mappings, or an empty array if none exist.
-     */
-    async getDecentralizedNamespaceDefinition(
-        namespaceFingerprint: string,
-    ): Promise<DecentralizedNamespaceDefinitionState[]> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const { response } = await this.#topologyRead.listDecentralizedNamespaceDefinition(
-            ListDecentralizedNamespaceDefinitionRequest.create({
-                baseQuery: headStateBaseQuery(synchronizerId),
-                filterNamespace: namespaceFingerprint,
-            }),
-            { meta: await this.#getMeta() },
-        );
-
-        return response.results.flatMap((result) => {
-            const item = result.item;
-            if (!item) {
-                return [];
-            }
-            return [
-                {
-                    namespace: item.decentralizedNamespace,
-                    threshold: item.threshold,
-                    owners: [...item.owners],
-                    serial: result.context?.serial ?? 0,
-                },
-            ];
-        });
-    }
-
-    /**
-     * Lists Party-to-Key (PTK) mappings for a party.
-     *
-     * Queries topology head state on the synchronizer.
-     *
-     * @param partyId - Full party identifier (e.g. `hint::1220…`).
-     * @returns All matching PTK mappings, or an empty array if none exist.
-     */
-    async getPartyToKeyMapping(partyId: string): Promise<PartyToKeyMappingState[]> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const { response } = await this.#topologyRead.listPartyToKeyMapping(
-            ListPartyToKeyMappingRequest.create({
-                baseQuery: headStateBaseQuery(synchronizerId),
-                filterParty: partyId,
-            }),
-            { meta: await this.#getMeta() },
-        );
-
-        return response.results.flatMap((result) => {
-            const item = result.item;
-            if (!item) {
-                return [];
-            }
-            return [
-                {
-                    party: item.party,
-                    threshold: item.threshold,
-                    signingKeyFingerprints: item.signingKeys.map((key) =>
-                        computePublicKeyFingerprint(key.publicKey),
-                    ),
-                    serial: result.context?.serial ?? 0,
-                },
-            ];
-        });
-    }
-
-    /**
-     * Lists Party-to-Participant (PTP) mappings for a party.
-     *
-     * Queries topology head state on the synchronizer.
-     *
-     * @param partyId - Full party identifier (e.g. `hint::1220…`).
-     * @param proposals - If `true`, query pending proposals instead of authorized mappings.
-     * @returns All matching PTP mappings, or an empty array if none exist.
-     */
-    async getPartyToParticipantMapping(
-        partyId: string,
-        proposals = false,
-    ): Promise<PartyToParticipantMappingState[]> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const { response } = await this.#topologyRead.listPartyToParticipant(
-            ListPartyToParticipantRequest.create({
-                baseQuery: headStateBaseQuery(synchronizerId, proposals),
-                filterParty: partyId,
-                // Empty string = no participant filter; return all hosting mappings for this party.
-                filterParticipant: '',
-            }),
-            { meta: await this.#getMeta() },
-        );
-
-        return response.results.flatMap((result) => {
-            const item = result.item;
-            if (!item) {
-                return [];
-            }
-            return [
-                {
-                    party: item.party,
-                    threshold: item.threshold,
-                    participants: item.participants.map((participant) => ({
-                        participantUid: participant.participantUid,
-                        permission: participant.permission,
-                    })),
-                    serial: result.context?.serial ?? 0,
-                },
-            ];
-        });
-    }
-
-    /**
-     * Builds an unsigned Namespace Delegation (NSD) topology transaction.
-     *
-     * Calls `GenerateTransactions` with an ADD_REPLACE mapping. The returned
-     * `transactionHash` must be signed by the namespace key.
-     *
-     * @param params - Owner public key and optional serial.
-     * @returns Unsigned topology transaction (`serializedTransaction`, `transactionHash`).
-     */
-    async createNamespaceDelegationTx(
-        params: CreateNamespaceDelegationTxParams,
-    ): Promise<GeneratedTopologyTransaction> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const mapping = buildNamespaceDelegationMapping(params.publicKeyDer);
-        return this.#generateTopologyTransaction(synchronizerId, mapping, params.serial ?? 0);
-    }
-
-    /**
-     * Builds an unsigned Decentralized Namespace Definition (DND) topology transaction.
-     *
-     * The decentralized namespace id is derived from `params.owners`. All owners
-     * must sign the transaction hash.
-     *
-     * @param params - Owner fingerprints, threshold, and optional serial.
-     * @returns Unsigned topology transaction (`serializedTransaction`, `transactionHash`).
-     */
-    async createDecentralizedNamespaceDefinitionTx(
-        params: CreateDecentralizedNamespaceDefinitionTxParams,
-    ): Promise<GeneratedTopologyTransaction> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const decentralizedNamespace = computeDecentralizedNamespace(params.owners);
-        const mapping = buildDecentralizedNamespaceDefinitionMapping(
-            decentralizedNamespace,
-            params.threshold,
-            params.owners,
-        );
-        return this.#generateTopologyTransaction(synchronizerId, mapping, params.serial ?? 0);
-    }
-
-    async updateDecentralizedNamespaceDefinitionTx(
-        params: UpdateDecentralizedNamespaceDefinitionTxParams,
-    ): Promise<GeneratedTopologyTransaction> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const mapping = buildDecentralizedNamespaceDefinitionMapping(
-            params.namespace,
-            params.threshold,
-            params.owners,
-        );
-        return this.#generateTopologyTransaction(synchronizerId, mapping, params.serial ?? 0);
-    }
-
-    /**
-     * Builds an unsigned Party-to-Key (PTK) topology transaction.
-     *
-     * Decentralized namespace owners must sign the transaction hash.
-     *
-     * @param params - Party id, signing keys, threshold, and optional serial.
-     * @returns Unsigned topology transaction (`serializedTransaction`, `transactionHash`).
-     */
-    async createPartyToKeyTx(
-        params: CreatePartyToKeyMappingTxParams,
-    ): Promise<GeneratedTopologyTransaction> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const mapping = buildPartyToKeyMapping(
-            params.partyId,
-            params.signingPublicKeyDers,
-            params.threshold,
-        );
-        return this.#generateTopologyTransaction(synchronizerId, mapping, params.serial ?? 0);
-    }
-
-    /**
-     * Builds an unsigned Party-to-Participant (PTP) topology transaction.
-     *
-     * Party owners sign the transaction hash. On submit, set `proposal: true` on the
-     * signed transaction so the hosting participant can authorize via `Authorize`.
-     *
-     * @param params - Party id, participant ids, threshold, and optional serial.
-     * @returns Unsigned topology transaction (`serializedTransaction`, `transactionHash`).
-     */
-    async createPartyToParticipantTx(
-        params: CreatePartyToParticipantMappingTxParams,
-    ): Promise<GeneratedTopologyTransaction> {
-        const synchronizerId = await this.#getSynchronizerId();
-        const mapping = buildPartyToParticipantMapping(
-            params.partyId,
-            params.participantIds,
-            params.threshold,
-        );
-        return this.#generateTopologyTransaction(synchronizerId, mapping, params.serial ?? 0);
-    }
-
-    /**
-     * Submits signed topology transactions to the synchronizer store.
-     *
-     * Multiple transactions are submitted atomically in one `AddTransactions` call.
-     * When batching, sign `computeMultiTransactionHash` over all transaction hashes
-     * and attach the same `MultiTransactionSignatures` to each entry.
-     *
-     * Set `proposal: true` on a transaction when the hosting participant must
-     * authorize that mapping afterward.
-     *
-     * @param transactions - One or more signed topology transactions.
-     * @throws {CantonError} If `transactions` is empty.
-     */
-    async submitTopologyTransactions(
-        transactions: readonly SignedTopologyTransaction[],
-    ): Promise<void> {
-        if (transactions.length === 0) {
-            throw new CantonError('AddTransactions requires at least one transaction');
-        }
-        const synchronizerId = await this.#getSynchronizerId();
-        await this.#topologyWrite.addTransactions(
-            AddTransactionsRequest.create({
-                transactions: [...transactions],
-                store: synchronizerStore(synchronizerId),
-            }),
-            { meta: await this.#getMeta() },
-        );
-    }
-
-    /** Closes the underlying gRPC transport. */
-    close(): void {
-        this.#transport.close();
-    }
-}

package/src/client/index.ts

@@ -1,24 +0,0 @@
-export * from './amulet';
-export { CantonClient } from './canton-client';
-export * from './grpc';
-export * from './interface';
-export * from './utils';
-
-// Topology Manager API
-export type { TopologySignature } from './topology/signing';
-export { buildMultiTransactionSignatures, buildSignedTransaction } from './topology/signing';
-export type {
-    CantonGrpcClientOptions,
-    CreateDecentralizedNamespaceDefinitionTxParams,
-    CreateNamespaceDelegationTxParams,
-    CreatePartyToKeyMappingTxParams,
-    CreatePartyToParticipantMappingTxParams,
-    DecentralizedNamespaceDefinitionState,
-    GeneratedTopologyTransaction,
-    NamespaceDelegationState,
-    PartyToKeyMappingState,
-    PartyToParticipantMappingState,
-    UpdateDecentralizedNamespaceDefinitionTxParams,
-} from './topology/types';
-export { computeDecentralizedNamespace, computeMultiTransactionHash } from './topology/utils';
-export type { SignedTopologyTransaction } from '@canton-network/core-ledger-proto';

package/src/client/topology/mappings.ts

@@ -1,152 +0,0 @@
-import {
-    CryptoKeyFormat,
-    DecentralizedNamespaceDefinition,
-    Enums_ParticipantPermission,
-    NamespaceDelegation,
-    PartyToKeyMapping,
-    PartyToParticipant,
-    PartyToParticipant_HostingParticipant,
-    SigningKeySpec,
-    SigningKeyUsage,
-    SigningPublicKey,
-    TopologyMapping,
-} from '@canton-network/core-ledger-proto';
-
-import { computePublicKeyFingerprint } from '../utils';
-
-/**
- * Builds a Canton protocol `SigningPublicKey` from a DER-encoded secp256k1 public key.
- *
- * Keys use X.509 SubjectPublicKeyInfo encoding with `NAMESPACE` and `PROTOCOL` usage,
- * as required by Canton topology mappings.
- *
- * @param publicKeyDer - DER-encoded secp256k1 public key (X.509 SubjectPublicKeyInfo).
- * @returns A `SigningPublicKey` for use in topology mapping protobuf fields.
- */
-function buildSigningPublicKey(publicKeyDer: Uint8Array): SigningPublicKey {
-    return SigningPublicKey.create({
-        format: CryptoKeyFormat.DER_X509_SUBJECT_PUBLIC_KEY_INFO,
-        publicKey: publicKeyDer,
-        usage: [SigningKeyUsage.NAMESPACE, SigningKeyUsage.PROTOCOL],
-        keySpec: SigningKeySpec.EC_SECP256K1,
-    });
-}
-
-/**
- * Builds a Namespace Delegation (NSD) topology mapping for a root owner key.
- *
- * Registers a self-rooted namespace: the namespace identifier is the public key
- * fingerprint, and the same key is the root delegation target. The unsigned
- * transaction produced from this mapping must be signed by that key alone.
- *
- * @param publicKeyDer - DER-encoded secp256k1 public key for the namespace owner.
- * @returns A `TopologyMapping` containing a root `NamespaceDelegation`.
- */
-export function buildNamespaceDelegationMapping(publicKeyDer: Uint8Array): TopologyMapping {
-    const namespace = computePublicKeyFingerprint(publicKeyDer);
-    return TopologyMapping.create({
-        mapping: {
-            oneofKind: 'namespaceDelegation',
-            namespaceDelegation: NamespaceDelegation.create({
-                namespace,
-                targetKey: buildSigningPublicKey(publicKeyDer),
-                isRootDelegation: true,
-            }),
-        },
-    });
-}
-
-/**
- * Builds a Decentralized Namespace Definition (DND) topology mapping.
- *
- * Defines a multi-owner namespace identified by `decentralizedNamespace`, with a
- * signing threshold over the listed owner key fingerprints. Every owner must
- * authorize the transaction.
- *
- * @param decentralizedNamespace - Decentralized namespace fingerprint (e.g. `1220…`).
- * @param threshold - Minimum number of owner signatures required (≤ `owners.length`).
- * @param owners - Owner namespace fingerprints (multihash hex strings).
- * @returns A `TopologyMapping` containing a `DecentralizedNamespaceDefinition`.
- */
-export function buildDecentralizedNamespaceDefinitionMapping(
-    decentralizedNamespace: string,
-    threshold: number,
-    owners: string[],
-): TopologyMapping {
-    return TopologyMapping.create({
-        mapping: {
-            oneofKind: 'decentralizedNamespaceDefinition',
-            decentralizedNamespaceDefinition: DecentralizedNamespaceDefinition.create({
-                decentralizedNamespace,
-                threshold,
-                owners,
-            }),
-        },
-    });
-}
-
-/**
- * Builds a Party-to-Key (PTK) topology mapping.
- *
- * Binds signing keys to a party and sets the threshold required to authorize
- * party-level topology changes. Decentralized namespace owners must co-sign
- * the transaction.
- *
- * @param partyId - Full party identifier (e.g. `hint::1220…`).
- * @param signingPublicKeyDers - DER-encoded signing public keys assigned to the party.
- * @param threshold - Minimum number of party signing keys required (≤ number of keys).
- * @returns A `TopologyMapping` containing a `PartyToKeyMapping`.
- */
-export function buildPartyToKeyMapping(
-    partyId: string,
-    signingPublicKeyDers: Uint8Array[],
-    threshold: number,
-): TopologyMapping {
-    return TopologyMapping.create({
-        mapping: {
-            oneofKind: 'partyToKeyMapping',
-            partyToKeyMapping: PartyToKeyMapping.create({
-                party: partyId,
-                threshold,
-                signingKeys: signingPublicKeyDers.map((publicKeyDer) =>
-                    buildSigningPublicKey(publicKeyDer),
-                ),
-            }),
-        },
-    });
-}
-
-/**
- * Builds a Party-to-Participant (PTP) topology mapping.
- *
- * Declares which participant nodes host the party. Each participant is granted
- * `CONFIRMATION` permission. On initial hosting, submit the signed transaction
- * with `proposal: true` so the participant can complete authorization via the
- * topology `Authorize` RPC.
- *
- * @param partyId - Full party identifier (e.g. `hint::1220…`).
- * @param participantIds - Participant UIDs that should host the party.
- * @param threshold - Hosting threshold (≤ `participantIds.length`).
- * @returns A `TopologyMapping` containing a `PartyToParticipant` mapping.
- */
-export function buildPartyToParticipantMapping(
-    partyId: string,
-    participantIds: string[],
-    threshold: number,
-): TopologyMapping {
-    return TopologyMapping.create({
-        mapping: {
-            oneofKind: 'partyToParticipant',
-            partyToParticipant: PartyToParticipant.create({
-                party: partyId,
-                threshold,
-                participants: participantIds.map((participantId) =>
-                    PartyToParticipant_HostingParticipant.create({
-                        participantUid: participantId,
-                        permission: Enums_ParticipantPermission.CONFIRMATION,
-                    }),
-                ),
-            }),
-        },
-    });
-}

package/src/client/topology/signing.ts

@@ -1,56 +0,0 @@
-import {
-    MultiTransactionSignatures,
-    Signature,
-    SignatureFormat,
-    SignedTopologyTransaction,
-    SigningAlgorithmSpec,
-} from '@canton-network/core-ledger-proto';
-
-/** A single namespace-key signature over the multi-transaction hash. */
-export type TopologySignature = {
-    /** Fingerprint of the signing key (Canton `signedBy`). */
-    signerFingerprint: string;
-    /** Raw DER ECDSA-SHA256 signature bytes over the multi-transaction hash. */
-    signatureBytes: Uint8Array;
-};
-
-/**
- * Wraps namespace-key signatures over one or more topology transaction hashes.
- *
- * Use with {@link computeMultiTransactionHash}: sign the multi-hash once per key,
- * then pass the raw signatures here to cover every hash in the batch.
- */
-export function buildMultiTransactionSignatures(
-    transactionHashes: Uint8Array[],
-    signatures: readonly TopologySignature[],
-): MultiTransactionSignatures {
-    return MultiTransactionSignatures.create({
-        transactionHashes,
-        signatures: signatures.map((entry) =>
-            Signature.create({
-                format: SignatureFormat.DER,
-                signature: entry.signatureBytes,
-                signedBy: entry.signerFingerprint,
-                signingAlgorithmSpec: SigningAlgorithmSpec.EC_DSA_SHA_256,
-            }),
-        ),
-    });
-}
-
-/**
- * Builds a {@link SignedTopologyTransaction} ready for
- * {@link CantonGrpcClient.submitTopologyTransactions}.
- *
- * Set `proposal: true` when the hosting participant must authorize the mapping.
- */
-export function buildSignedTransaction(
-    transaction: Uint8Array,
-    multiTransactionSignatures: MultiTransactionSignatures[],
-    proposal = false,
-): SignedTopologyTransaction {
-    return SignedTopologyTransaction.create({
-        transaction,
-        multiTransactionSignatures,
-        proposal,
-    });
-}