@distrohelena/canton-typescript-sdk 0.1.16 → 0.1.17

package/dist/transports/grpc/mappers/topology-manager-write-mapper.js

@@ -1,475 +0,0 @@
-import { ValidationError } from "../../../core/errors/validation-error.js";
-import { AddTopologyTransactionsResponse } from "../../../core/types/responses/add-topology-transactions-response.js";
-import { AuthorizeTopologyTransactionsResponse } from "../../../core/types/responses/authorize-topology-transactions-response.js";
-import { GenerateTopologyTransactionsResponse } from "../../../core/types/responses/generate-topology-transactions-response.js";
-import { ImportTopologySnapshotResponse } from "../../../core/types/responses/import-topology-snapshot-response.js";
-import { ImportTopologySnapshotV2Response } from "../../../core/types/responses/import-topology-snapshot-v2-response.js";
-import { SignTopologyTransactionsResponse } from "../../../core/types/responses/sign-topology-transactions-response.js";
-import { GeneratedTopologyTransaction } from "../../../core/types/topology/generated-topology-transaction.js";
-import { DecentralizedNamespaceDefinition } from "../../../core/types/topology/decentralized-namespace-definition.js";
-import { MultiTopologyTransactionSignature } from "../../../core/types/topology/multi-topology-transaction-signature.js";
-import { NamespaceDelegation, NamespaceDelegationRestrictionKind, } from "../../../core/types/topology/namespace-delegation.js";
-import { PartyToParticipant, PartyToParticipantOnboarding, } from "../../../core/types/topology/party-to-participant.js";
-import { SignedTopologyTransaction } from "../../../core/types/topology/signed-topology-transaction.js";
-import { TopologyForceFlag } from "../../../core/types/topology/topology-force-flag.js";
-import { TopologySignatureDelegation } from "../../../core/types/topology/topology-signature-delegation.js";
-import { TopologyTransactionSignature } from "../../../core/types/topology/topology-transaction-signature.js";
-import { CryptoKeyFormat, SignatureFormat as GrpcSignatureFormat, SigningAlgorithmSpec, SigningKeyScheme, SigningKeySpec, SigningKeyUsage, } from "../generated/canton/com/digitalasset/canton/crypto/v30/crypto.js";
-import { ForceFlag, } from "../generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_write_service.js";
-import { Enums_ParticipantPermission, } from "../generated/canton/com/digitalasset/canton/protocol/v30/topology.js";
-import { mapGrpcTopologyChangeOp, mapGrpcTopologyMappingCode, mapGrpcTopologyStoreId, } from "./topology-common-mapper.js";
-export function mapGrpcGenerateTopologyTransactionsRequest(request) {
-    return {
-        proposals: request.proposals.map(mapGrpcGenerateTopologyTransactionsProposal),
-    };
-}
-export function mapGrpcGenerateTopologyTransactionsResponse(payload) {
-    return new GenerateTopologyTransactionsResponse({
-        generatedTransactions: (payload.generatedTransactions ?? []).map((item) => new GeneratedTopologyTransaction({
-            serializedTransaction: item.serializedTransaction,
-            transactionHash: item.transactionHash,
-        })),
-    });
-}
-export function mapGrpcAuthorizeTopologyTransactionsRequest(request) {
-    return {
-        type: request.proposal !== undefined
-            ? {
-                oneofKind: "proposal",
-                proposal: mapGrpcAuthorizeTopologyTransactionsProposal(request.proposal),
-            }
-            : request.transactionHash !== undefined
-                ? {
-                    oneofKind: "transactionHash",
-                    transactionHash: request.transactionHash,
-                }
-                : {
-                    oneofKind: undefined,
-                },
-        mustFullyAuthorize: request.mustFullyAuthorize,
-        forceChanges: request.forceChanges.map(mapGrpcForceFlag),
-        signedBy: [...request.signedBy],
-        store: mapGrpcTopologyStoreId(request.store),
-        waitToBecomeEffective: mapGrpcDuration(request.waitToBecomeEffective),
-    };
-}
-export function mapGrpcAuthorizeTopologyTransactionsResponse(payload) {
-    return new AuthorizeTopologyTransactionsResponse({
-        transaction: payload.transaction === undefined
-            ? undefined
-            : mapSdkSignedTopologyTransaction(payload.transaction),
-    });
-}
-export function mapGrpcAddTopologyTransactionsRequest(request) {
-    return {
-        transactions: request.transactions.map(mapGrpcSignedTopologyTransaction),
-        forceChanges: request.forceChanges.map(mapGrpcForceFlag),
-        store: mapGrpcTopologyStoreId(request.store),
-        waitToBecomeEffective: mapGrpcDuration(request.waitToBecomeEffective),
-    };
-}
-export function mapGrpcAddTopologyTransactionsResponse(_payload) {
-    return new AddTopologyTransactionsResponse();
-}
-export function mapGrpcImportTopologySnapshotRequest(request) {
-    return {
-        topologySnapshot: new Uint8Array(request.topologySnapshot),
-        store: mapGrpcTopologyStoreId(request.store),
-        waitToBecomeEffective: mapGrpcDuration(request.waitToBecomeEffective),
-    };
-}
-export function mapGrpcImportTopologySnapshotResponse(_payload) {
-    return new ImportTopologySnapshotResponse();
-}
-export function mapGrpcImportTopologySnapshotV2Request(request) {
-    return {
-        topologySnapshot: new Uint8Array(request.topologySnapshot),
-        store: mapGrpcTopologyStoreId(request.store),
-        waitToBecomeEffective: mapGrpcDuration(request.waitToBecomeEffective),
-    };
-}
-export function mapGrpcImportTopologySnapshotV2Response(_payload) {
-    return new ImportTopologySnapshotV2Response();
-}
-export function mapGrpcSignTopologyTransactionsRequest(request) {
-    return {
-        transactions: request.transactions.map(mapGrpcSignedTopologyTransaction),
-        signedBy: [...request.signedBy],
-        store: mapGrpcTopologyStoreId(request.store),
-        forceFlags: request.forceFlags.map(mapGrpcForceFlag),
-    };
-}
-export function mapGrpcSignTopologyTransactionsResponse(payload) {
-    return new SignTopologyTransactionsResponse({
-        transactions: (payload.transactions ?? []).map(mapSdkSignedTopologyTransaction),
-    });
-}
-function mapGrpcGenerateTopologyTransactionsProposal(proposal) {
-    return {
-        operation: mapGrpcTopologyChangeOp(proposal.operation),
-        serial: proposal.serial,
-        mapping: mapGrpcTopologyMapping(proposal.mapping),
-        store: mapGrpcTopologyStoreId(proposal.store),
-    };
-}
-function mapGrpcAuthorizeTopologyTransactionsProposal(proposal) {
-    return {
-        change: mapGrpcTopologyChangeOp(proposal.operation),
-        serial: proposal.serial,
-        mapping: mapGrpcTopologyMapping(proposal.mapping),
-    };
-}
-function mapGrpcTopologyMapping(mapping) {
-    if (mapping === undefined) {
-        return undefined;
-    }
-    else if (mapping instanceof PartyToParticipant) {
-        return {
-            mapping: {
-                oneofKind: "partyToParticipant",
-                partyToParticipant: mapGrpcPartyToParticipant(mapping),
-            },
-        };
-    }
-    else if (mapping instanceof DecentralizedNamespaceDefinition) {
-        return {
-            mapping: {
-                oneofKind: "decentralizedNamespaceDefinition",
-                decentralizedNamespaceDefinition: mapGrpcDecentralizedNamespaceDefinition(mapping),
-            },
-        };
-    }
-    else if (mapping instanceof NamespaceDelegation) {
-        return {
-            mapping: {
-                oneofKind: "namespaceDelegation",
-                namespaceDelegation: mapGrpcNamespaceDelegation(mapping),
-            },
-        };
-    }
-    throw new ValidationError(`Unsupported topology write mapping type: ${mapping.constructor.name}.`);
-}
-function mapGrpcDecentralizedNamespaceDefinition(value) {
-    return {
-        decentralizedNamespace: value.decentralizedNamespace,
-        threshold: value.threshold,
-        owners: [...value.owners],
-    };
-}
-function mapGrpcNamespaceDelegation(value) {
-    return {
-        namespace: value.namespace,
-        targetKey: value.targetKey === undefined
-            ? undefined
-            : mapGrpcSigningPublicKey(value.targetKey),
-        isRootDelegation: value.isRootDelegation,
-        restriction: mapGrpcNamespaceDelegationRestriction(value),
-    };
-}
-function mapGrpcNamespaceDelegationRestriction(value) {
-    switch (value.restriction?.kind) {
-        case NamespaceDelegationRestrictionKind.canSignAllMappings:
-            return {
-                oneofKind: "canSignAllMappings",
-                canSignAllMappings: {},
-            };
-        case NamespaceDelegationRestrictionKind.canSignAllButNamespaceDelegations:
-            return {
-                oneofKind: "canSignAllButNamespaceDelegations",
-                canSignAllButNamespaceDelegations: {},
-            };
-        case NamespaceDelegationRestrictionKind.canSignSpecificMappings:
-            return {
-                oneofKind: "canSignSpecificMapings",
-                canSignSpecificMapings: {
-                    mappings: value.restriction.mappings.map(mapGrpcTopologyMappingCode),
-                },
-            };
-        default:
-            return { oneofKind: undefined };
-    }
-}
-function mapGrpcPartyToParticipant(value) {
-    return {
-        party: value.party,
-        threshold: value.threshold,
-        participants: value.participants.map(mapGrpcPartyToParticipantParticipant),
-        partySigningKeys: mapGrpcSigningKeysWithThreshold(value.partySigningKeys),
-    };
-}
-function mapGrpcPartyToParticipantParticipant(value) {
-    return {
-        participantUid: value.participantUid,
-        permission: mapGrpcParticipantPermission(value.permission),
-        onboarding: value.onboarding instanceof PartyToParticipantOnboarding
-            ? {}
-            : undefined,
-    };
-}
-function mapGrpcSigningKeysWithThreshold(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    return {
-        threshold: value.threshold,
-        keys: value.keys.map(mapGrpcSigningPublicKey),
-    };
-}
-function mapGrpcSigningPublicKey(value) {
-    return {
-        format: mapGrpcCryptoKeyFormat(value.format),
-        publicKey: new Uint8Array(value.publicKey),
-        scheme: mapGrpcSigningKeyScheme(value.scheme, value.keySpec),
-        usage: value.usage.map(mapGrpcSigningKeyUsage),
-        keySpec: mapGrpcSigningKeySpec(value.keySpec),
-    };
-}
-function mapGrpcSignedTopologyTransaction(value) {
-    return {
-        transaction: new Uint8Array(value.transaction),
-        signatures: value.signatures.map(mapGrpcTopologyTransactionSignature),
-        proposal: value.proposal,
-        multiTransactionSignatures: value.multiTransactionSignatures.map(mapGrpcMultiTopologyTransactionSignature),
-    };
-}
-function mapSdkSignedTopologyTransaction(value) {
-    return new SignedTopologyTransaction({
-        transaction: value.transaction,
-        signatures: (value.signatures ?? []).map(mapSdkTopologyTransactionSignature),
-        proposal: value.proposal ?? false,
-        multiTransactionSignatures: (value.multiTransactionSignatures ?? []).map(mapSdkMultiTopologyTransactionSignature),
-    });
-}
-function mapGrpcTopologyTransactionSignature(value) {
-    return {
-        format: mapGrpcSignatureFormat(value.format),
-        signature: new Uint8Array(value.signature),
-        signedBy: value.signedByFingerprint,
-        signingAlgorithmSpec: mapGrpcSigningAlgorithmSpec(value.signingAlgorithmSpec),
-        signatureDelegation: value.signatureDelegation === undefined
-            ? undefined
-            : mapGrpcSignatureDelegation(value.signatureDelegation),
-    };
-}
-function mapSdkTopologyTransactionSignature(value) {
-    return new TopologyTransactionSignature({
-        format: mapSdkSignatureFormat(value.format),
-        signature: value.signature,
-        signedByFingerprint: value.signedBy ?? "",
-        signingAlgorithmSpec: mapSdkSigningAlgorithmSpec(value.signingAlgorithmSpec),
-        signatureDelegation: value.signatureDelegation === undefined
-            ? undefined
-            : mapSdkSignatureDelegation(value.signatureDelegation),
-    });
-}
-function mapGrpcMultiTopologyTransactionSignature(value) {
-    return {
-        transactionHashes: value.transactionHashes.map((item) => new Uint8Array(item)),
-        signatures: value.signatures.map(mapGrpcTopologyTransactionSignature),
-    };
-}
-function mapSdkMultiTopologyTransactionSignature(value) {
-    return new MultiTopologyTransactionSignature({
-        transactionHashes: (value.transactionHashes ?? []).map((item) => new Uint8Array(item)),
-        signatures: (value.signatures ?? []).map(mapSdkTopologyTransactionSignature),
-    });
-}
-function mapGrpcSignatureDelegation(value) {
-    return {
-        sessionKey: new Uint8Array(value.sessionKey),
-        sessionKeySpec: mapGrpcSigningKeySpec(value.sessionKeySpec),
-        validityPeriodFromInclusive: value.validityPeriodFromInclusive,
-        validityPeriodDurationSeconds: value.validityPeriodDurationSeconds,
-        format: mapGrpcSignatureFormat(value.format),
-        signature: new Uint8Array(value.signature),
-        signingAlgorithmSpec: mapGrpcSigningAlgorithmSpec(value.signingAlgorithmSpec),
-    };
-}
-function mapSdkSignatureDelegation(value) {
-    return new TopologySignatureDelegation({
-        sessionKey: value.sessionKey,
-        sessionKeySpec: mapSdkSigningKeySpec(value.sessionKeySpec),
-        validityPeriodFromInclusive: value.validityPeriodFromInclusive ?? "0",
-        validityPeriodDurationSeconds: value.validityPeriodDurationSeconds ?? 0,
-        format: mapSdkSignatureFormat(value.format),
-        signature: value.signature,
-        signingAlgorithmSpec: mapSdkSigningAlgorithmSpec(value.signingAlgorithmSpec),
-    });
-}
-function mapGrpcDuration(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    return {
-        seconds: value.seconds,
-        nanos: value.nanos,
-    };
-}
-function mapGrpcForceFlag(value) {
-    switch (value) {
-        case TopologyForceFlag.alienMember:
-            return ForceFlag.ALIEN_MEMBER;
-        case TopologyForceFlag.ledgerTimeRecordTimeToleranceIncrease:
-            return ForceFlag.LEDGER_TIME_RECORD_TIME_TOLERANCE_INCREASE;
-        case TopologyForceFlag.allowUnknownPackage:
-            return ForceFlag.ALLOW_UNKNOWN_PACKAGE;
-        case TopologyForceFlag.allowUnvettedDependencies:
-            return ForceFlag.ALLOW_UNVETTED_DEPENDENCIES;
-        case TopologyForceFlag.disablePartyWithActiveContracts:
-            return ForceFlag.DISABLE_PARTY_WITH_ACTIVE_CONTRACTS;
-        case TopologyForceFlag.unspecified:
-        default:
-            return ForceFlag.UNSPECIFIED;
-    }
-}
-function mapGrpcParticipantPermission(value) {
-    switch (value) {
-        case "submission":
-            return Enums_ParticipantPermission.SUBMISSION;
-        case "confirmation":
-            return Enums_ParticipantPermission.CONFIRMATION;
-        case "observation":
-            return Enums_ParticipantPermission.OBSERVATION;
-        case "unspecified":
-        default:
-            return Enums_ParticipantPermission.UNSPECIFIED;
-    }
-}
-function mapGrpcSignatureFormat(value) {
-    switch (value) {
-        case "raw":
-            return GrpcSignatureFormat.RAW;
-        case "der":
-            return GrpcSignatureFormat.DER;
-        case "concat":
-            return GrpcSignatureFormat.CONCAT;
-        case "symbolic":
-            return GrpcSignatureFormat.SYMBOLIC;
-        default:
-            return GrpcSignatureFormat.UNSPECIFIED;
-    }
-}
-function mapSdkSignatureFormat(value) {
-    switch (value) {
-        case GrpcSignatureFormat.RAW:
-            return "raw";
-        case GrpcSignatureFormat.DER:
-            return "der";
-        case GrpcSignatureFormat.CONCAT:
-            return "concat";
-        case GrpcSignatureFormat.SYMBOLIC:
-            return "symbolic";
-        case GrpcSignatureFormat.UNSPECIFIED:
-        default:
-            return "unspecified";
-    }
-}
-function mapGrpcSigningAlgorithmSpec(value) {
-    switch (value) {
-        case "ed25519":
-            return SigningAlgorithmSpec.ED25519;
-        case "ecDsaSha256":
-            return SigningAlgorithmSpec.EC_DSA_SHA_256;
-        case "ecDsaSha384":
-            return SigningAlgorithmSpec.EC_DSA_SHA_384;
-        case "mlDsa65":
-            return SigningAlgorithmSpec.ML_DSA_65;
-        default:
-            return SigningAlgorithmSpec.UNSPECIFIED;
-    }
-}
-function mapSdkSigningAlgorithmSpec(value) {
-    switch (value) {
-        case SigningAlgorithmSpec.ED25519:
-            return "ed25519";
-        case SigningAlgorithmSpec.EC_DSA_SHA_256:
-            return "ecDsaSha256";
-        case SigningAlgorithmSpec.EC_DSA_SHA_384:
-            return "ecDsaSha384";
-        case SigningAlgorithmSpec.ML_DSA_65:
-            return "mlDsa65";
-        case SigningAlgorithmSpec.UNSPECIFIED:
-        default:
-            return "unspecified";
-    }
-}
-function mapGrpcCryptoKeyFormat(value) {
-    switch (value) {
-        case "der":
-            return CryptoKeyFormat.DER;
-        case "raw":
-            return CryptoKeyFormat.RAW;
-        case "derX509SubjectPublicKeyInfo":
-            return CryptoKeyFormat.DER_X509_SUBJECT_PUBLIC_KEY_INFO;
-        case "derPkcs8PrivateKeyInfo":
-            return CryptoKeyFormat.DER_PKCS8_PRIVATE_KEY_INFO;
-        case "symbolic":
-            return CryptoKeyFormat.SYMBOLIC;
-        default:
-            return CryptoKeyFormat.UNSPECIFIED;
-    }
-}
-function mapGrpcSigningKeyUsage(value) {
-    switch (value) {
-        case "namespace":
-            return SigningKeyUsage.NAMESPACE;
-        case "identityDelegation":
-            return SigningKeyUsage.IDENTITY_DELEGATION;
-        case "sequencerAuthentication":
-            return SigningKeyUsage.SEQUENCER_AUTHENTICATION;
-        case "protocol":
-            return SigningKeyUsage.PROTOCOL;
-        case "proofOfOwnership":
-            return SigningKeyUsage.PROOF_OF_OWNERSHIP;
-        default:
-            return SigningKeyUsage.UNSPECIFIED;
-    }
-}
-function mapGrpcSigningKeySpec(value) {
-    switch (value) {
-        case "ecCurve25519":
-            return SigningKeySpec.EC_CURVE25519;
-        case "ecP256":
-            return SigningKeySpec.EC_P256;
-        case "ecP384":
-            return SigningKeySpec.EC_P384;
-        case "ecSecp256k1":
-            return SigningKeySpec.EC_SECP256K1;
-        case "mlDsa65":
-            return SigningKeySpec.ML_DSA_65;
-        default:
-            return SigningKeySpec.UNSPECIFIED;
-    }
-}
-function mapGrpcSigningKeyScheme(scheme, keySpec) {
-    switch (scheme ?? keySpec) {
-        case "ed25519":
-        case "ecCurve25519":
-            return SigningKeyScheme.ED25519;
-        case "ecDsaP256":
-        case "ecP256":
-            return SigningKeyScheme.EC_DSA_P256;
-        case "ecDsaP384":
-        case "ecP384":
-            return SigningKeyScheme.EC_DSA_P384;
-        default:
-            return SigningKeyScheme.UNSPECIFIED;
-    }
-}
-function mapSdkSigningKeySpec(value) {
-    switch (value) {
-        case SigningKeySpec.EC_CURVE25519:
-            return "ecCurve25519";
-        case SigningKeySpec.EC_P256:
-            return "ecP256";
-        case SigningKeySpec.EC_P384:
-            return "ecP384";
-        case SigningKeySpec.EC_SECP256K1:
-            return "ecSecp256k1";
-        case SigningKeySpec.ML_DSA_65:
-            return "mlDsa65";
-        case SigningKeySpec.UNSPECIFIED:
-        default:
-            return "unspecified";
-    }
-}