@layerzerolabs/common-canton 1.2.68 → 1.2.70

package/src/client/topology/synchronizer-connectivity.ts

@@ -1,111 +0,0 @@
-// `@protobuf-ts/runtime` and `@protobuf-ts/runtime-rpc` are already in the tree as
-// transitive deps of `@canton-network/core-ledger-proto` (and `@protobuf-ts/grpc-transport`),
-// so declaring them here adds no new dependency — pnpm's isolation just requires this
-// package to list them before it can import them directly.
-import { MessageType, RepeatType, ScalarType } from '@protobuf-ts/runtime';
-import {
-    type MethodInfo,
-    type RpcOptions,
-    type RpcTransport,
-    ServiceType,
-    stackIntercept,
-    type UnaryCall,
-} from '@protobuf-ts/runtime-rpc';
-
-/**
- * Minimal hand-written client for the Canton participant admin
- * `SynchronizerConnectivityService.ListConnectedSynchronizers` RPC.
- *
- * The published `@canton-network/core-ledger-proto` package does not ship the
- * `com.digitalasset.canton.admin.participant.v30` namespace, so the message and
- * service descriptors required for synchronizer discovery are declared here
- * against the same `@protobuf-ts` runtime the generated topology clients use.
- *
- * Field numbers mirror the `SynchronizerConnectivityService` definition in the
- * Canton `com.digitalasset.canton.admin.participant.v30` proto package; they track
- * the Canton version rather than any published package, so re-verify them when
- * upgrading Canton.
- *
- * TODO: the synchronizer id is also resolvable via the JSON Ledger API
- * (`/v2/state/connected-synchronizers`), in which case this hand-written gRPC
- * client can be removed — but consumers would then need to pass a JSON API URL too.
- */
-
-const SERVICE_NAME =
-    'com.digitalasset.canton.admin.participant.v30.SynchronizerConnectivityService';
-
-/** Empty request for `ListConnectedSynchronizers`. */
-export type ListConnectedSynchronizersRequest = Record<string, never>;
-
-/** A single connected-synchronizer entry. */
-export type ConnectedSynchronizer = {
-    /** Human-readable synchronizer alias (e.g. `global`). */
-    synchronizerAlias: string;
-    /** Logical synchronizer id — the value accepted by topology `BaseQuery.store`. */
-    synchronizerId: string;
-    /** Physical synchronizer id (logical id plus a `::<protocol>-<serial>` suffix). */
-    physicalSynchronizerId: string;
-    /** Whether the participant's connection to the synchronizer is healthy. */
-    healthy: boolean;
-};
-
-/** Response for `ListConnectedSynchronizers`. */
-export type ListConnectedSynchronizersResponse = {
-    connectedSynchronizers: ConnectedSynchronizer[];
-};
-
-const connectedSynchronizerMessage = new MessageType<ConnectedSynchronizer>(
-    `${SERVICE_NAME}.ListConnectedSynchronizersResponse.Result`,
-    [
-        { no: 1, name: 'synchronizer_alias', kind: 'scalar', T: ScalarType.STRING },
-        { no: 2, name: 'synchronizer_id', kind: 'scalar', T: ScalarType.STRING },
-        { no: 3, name: 'physical_synchronizer_id', kind: 'scalar', T: ScalarType.STRING },
-        { no: 4, name: 'healthy', kind: 'scalar', T: ScalarType.BOOL },
-    ],
-);
-
-const requestMessage = new MessageType<ListConnectedSynchronizersRequest>(
-    `${SERVICE_NAME}.ListConnectedSynchronizersRequest`,
-    [],
-);
-
-const responseMessage = new MessageType<ListConnectedSynchronizersResponse>(
-    `${SERVICE_NAME}.ListConnectedSynchronizersResponse`,
-    [
-        {
-            no: 1,
-            name: 'connected_synchronizers',
-            kind: 'message',
-            repeat: RepeatType.UNPACKED,
-            T: () => connectedSynchronizerMessage,
-        },
-    ],
-);
-
-const service = new ServiceType(SERVICE_NAME, [
-    { name: 'ListConnectedSynchronizers', options: {}, I: requestMessage, O: responseMessage },
-]);
-
-/** Client for the participant admin `SynchronizerConnectivityService`. */
-export class SynchronizerConnectivityServiceClient {
-    readonly #transport: RpcTransport;
-
-    constructor(transport: RpcTransport) {
-        this.#transport = transport;
-    }
-
-    /** Lists synchronizers the participant is currently connected to. */
-    listConnectedSynchronizers(
-        input: ListConnectedSynchronizersRequest,
-        options?: RpcOptions,
-    ): UnaryCall<ListConnectedSynchronizersRequest, ListConnectedSynchronizersResponse> {
-        const method = service.methods[0] as MethodInfo<
-            ListConnectedSynchronizersRequest,
-            ListConnectedSynchronizersResponse
-        >;
-        return stackIntercept<
-            ListConnectedSynchronizersRequest,
-            ListConnectedSynchronizersResponse
-        >('unary', this.#transport, method, this.#transport.mergeOptions(options), input);
-    }
-}

package/src/client/topology/utils.ts

@@ -1,114 +0,0 @@
-import { BaseQuery, Empty, StoreId } from '@canton-network/core-ledger-proto';
-import { ChannelCredentials } from '@grpc/grpc-js';
-
-import { bytesToHex } from '@layerzerolabs/common-encoding-utils';
-
-import { CantonError } from '../../errors';
-import { cantonMultihash } from '../utils';
-
-/** Canton hash purpose for decentralized namespace derivation. */
-const HASH_PURPOSE_DECENTRALIZED_NAMESPACE = 37;
-
-/** Canton hash purpose for multi-transaction topology signing. */
-const HASH_PURPOSE_MULTI_TRANSACTION = 55;
-
-/**
- * Computes the decentralized namespace fingerprint from owner key fingerprints.
- *
- * Owners are sorted lexicographically, then hashed as
- * `1220` + SHA256(purpose=37 || for each owner: len(utf8) || utf8).
- */
-export function computeDecentralizedNamespace(owners: string[]): string {
-    const sorted = [...owners].sort();
-    const parts: Buffer[] = [];
-    for (const owner of sorted) {
-        const ownerBytes = Buffer.from(owner, 'utf-8');
-        const lengthPrefix = Buffer.alloc(4);
-        lengthPrefix.writeUInt32BE(ownerBytes.length);
-        parts.push(lengthPrefix, ownerBytes);
-    }
-    return bytesToHex(cantonMultihash(HASH_PURPOSE_DECENTRALIZED_NAMESPACE, Buffer.concat(parts)));
-}
-
-/**
- * Combines topology transaction hashes into the digest Canton expects signed.
- *
- * Hashes are sorted lexicographically, count-prefixed, each length-prefixed, then
- * hashed with purpose 55. Pass a single hash when signing one transaction —
- * Canton always uses this multi-transaction format for `AddTransactions`.
- */
-export function computeMultiTransactionHash(hashes: Uint8Array[]): Uint8Array {
-    const sorted = [...hashes].sort((left, right) =>
-        Buffer.compare(Buffer.from(left), Buffer.from(right)),
-    );
-    const parts: Buffer[] = [];
-    const countBuffer = Buffer.alloc(4);
-    countBuffer.writeUInt32BE(sorted.length);
-    parts.push(countBuffer);
-    for (const hash of sorted) {
-        const lengthBuffer = Buffer.alloc(4);
-        lengthBuffer.writeUInt32BE(hash.length);
-        parts.push(lengthBuffer, Buffer.from(hash));
-    }
-    return cantonMultihash(HASH_PURPOSE_MULTI_TRANSACTION, Buffer.concat(parts));
-}
-
-/**
- * Builds a topology `StoreId` scoped to a synchronizer.
- *
- * Used as the `store` field on topology read/write RPC requests.
- */
-export function synchronizerStore(synchronizerId: string): StoreId {
-    return StoreId.create({
-        store: { oneofKind: 'synchronizer', synchronizer: { id: synchronizerId } },
-    });
-}
-
-/**
- * Builds a topology `BaseQuery` at synchronizer head state.
- *
- * Used as the `baseQuery` field on topology list RPC requests.
- */
-export function headStateBaseQuery(synchronizerId: string, proposals = false): BaseQuery {
-    return BaseQuery.create({
-        store: synchronizerStore(synchronizerId),
-        timeQuery: { oneofKind: 'headState', headState: Empty.create({}) },
-        proposals,
-    });
-}
-
-const LOOPBACK_HOSTNAMES = new Set(['localhost', '::1']);
-const LOOPBACK_IPV4 = /^127(\.\d{1,3}){3}$/;
-
-/**
- * Whether a `host:port` target addresses the local machine.
- */
-const isLoopbackHost = (host: string): boolean => {
-    const hostname = host
-        .replace(/:\d+$/, '')
-        .replace(/^\[(.*)\]$/, '$1')
-        .toLowerCase();
-    return LOOPBACK_HOSTNAMES.has(hostname) || LOOPBACK_IPV4.test(hostname);
-};
-
-/**
- * Builds gRPC channel credentials for the Canton admin API.
- *
- * Encrypted whatever the port, because every admin call carries a reusable bearer token.
- *
- * @throws {CantonError} If an unencrypted channel is asked for on a remote host.
- */
-export const buildChannelCredentials = (
-    host: string,
-    insecureTransport = false,
-): ChannelCredentials => {
-    if (!insecureTransport) {
-        return ChannelCredentials.createSsl();
-    } else if (!isLoopbackHost(host)) {
-        throw new CantonError(
-            `Canton admin API requires an encrypted channel for a remote host: ${host}`,
-        );
-    }
-
-    return ChannelCredentials.createInsecure();
-};

package/src/client/utils.ts

@@ -1,78 +0,0 @@
-import { createHash } from 'node:crypto';
-
-import { bytesToHex } from '@layerzerolabs/common-encoding-utils';
-
-import { SECP256K1_SPKI_DER_HEADER } from '../crypto';
-import type { CantonTransaction, CantonUpdate } from './interface';
-
-/**
- * Extract transactions from Canton updates.
- * Filters out checkpoints, reassignments, and topology transactions.
- */
-export function extractTransactions(updates: CantonUpdate[]): CantonTransaction[] {
-    return updates.flatMap((update) => ('Transaction' in update ? [update.Transaction.value] : []));
-}
-
-const HASH_PURPOSE_PUBLIC_KEY_FINGERPRINT = 12;
-const HASH_PURPOSE_DECENTRALIZED_NAMESPACE = 37;
-const MULTIHASH_SHA256_PREFIX = new Uint8Array([0x12, 0x20]);
-
-/**
- * Canton multihash: `0x1220 || SHA-256(BE32(purpose) || data)`.
- */
-export function cantonMultihash(purpose: number, data: Uint8Array): Uint8Array {
-    const purposePrefix = new Uint8Array(4);
-    new DataView(purposePrefix.buffer).setUint32(0, purpose);
-
-    const hash = createHash('sha256').update(purposePrefix).update(data).digest();
-
-    const result = new Uint8Array(MULTIHASH_SHA256_PREFIX.length + hash.length);
-    result.set(MULTIHASH_SHA256_PREFIX);
-    result.set(hash, MULTIHASH_SHA256_PREFIX.length);
-    return result;
-}
-
-/**
- * Canton fingerprint for a DER-encoded public key (purpose 12).
- * For root NSD, this is also the namespace id.
- */
-export function computePublicKeyFingerprint(publicKeyDer: Uint8Array): string {
-    return bytesToHex(cantonMultihash(HASH_PURPOSE_PUBLIC_KEY_FINGERPRINT, publicKeyDer));
-}
-
-/**
- * Computes the Canton fingerprint for an uncompressed secp256k1 public key.
- * DER-encodes the key, then computes hex(SHA-256 multihash of purpose=12 || publicKeyDer).
- */
-export function computeCantonFingerprint(uncompressedPublicKey: Uint8Array): string {
-    const publicKeyDer = new Uint8Array(
-        SECP256K1_SPKI_DER_HEADER.length + uncompressedPublicKey.length,
-    );
-    publicKeyDer.set(SECP256K1_SPKI_DER_HEADER);
-    publicKeyDer.set(uncompressedPublicKey, SECP256K1_SPKI_DER_HEADER.length);
-
-    return computePublicKeyFingerprint(publicKeyDer);
-}
-
-/**
- * Deterministic decentralized-namespace fingerprint from owner key fingerprints.
- * `"1220" + SHA256(purpose=37 || for each sorted owner: len(utf8) || utf8)`.
- *
- * For threshold-1 / single-owner namespaces this is `computeDecentralizedNamespace([keyFp])`,
- * which is the party id suffix — not the raw key fingerprint.
- */
-export function computeDecentralizedNamespace(owners: string[]): string {
-    const sorted = [...owners].map((owner) => owner.replace(/^0x/i, '')).sort();
-    const hash = createHash('sha256');
-    const purposeBuf = Buffer.alloc(4);
-    purposeBuf.writeUInt32BE(HASH_PURPOSE_DECENTRALIZED_NAMESPACE);
-    hash.update(purposeBuf);
-    for (const owner of sorted) {
-        const ownerBuf = Buffer.from(owner, 'utf-8');
-        const lenBuf = Buffer.alloc(4);
-        lenBuf.writeUInt32BE(ownerBuf.length);
-        hash.update(lenBuf);
-        hash.update(ownerBuf);
-    }
-    return `1220${hash.digest('hex')}`;
-}

package/src/crypto.ts

@@ -1,42 +0,0 @@
-/**
- * gRPC-free secp256k1 / DER helpers shared across Canton packages. Kept in a
- * dependency-light module (no ledger client, no ethers) so pure encoding/signing
- * SDKs can reuse it without pulling the gRPC client graph.
- *
- * DER signature encoding reuses `@noble/secp256k1` rather than hand-rolling ASN.1.
- */
-
-import * as secp256k1 from '@noble/secp256k1';
-
-import { trim0x } from '@layerzerolabs/common-encoding-utils';
-
-/** DER header for secp256k1 SubjectPublicKeyInfo (23 bytes), up to the `00` bit-string pad. */
-export const SECP256K1_SPKI_DER_HEADER = new Uint8Array([
-    0x30, 0x56, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x05, 0x2b,
-    0x81, 0x04, 0x00, 0x0a, 0x03, 0x42, 0x00,
-]);
-
-/** Hex form of {@link SECP256K1_SPKI_DER_HEADER} (lowercase, no `0x`). */
-export const SECP256K1_SPKI_DER_HEADER_HEX = Buffer.from(SECP256K1_SPKI_DER_HEADER).toString('hex');
-
-/**
- * Wrap an uncompressed `0x04‖X‖Y` secp256k1 public key as hex-encoded SPKI-DER
- * (the form the Canton ledger's `MultiSig.SignerSignature` carries).
- */
-export function publicKeyToSpkiDer(uncompressedPublicKey: string): string {
-    const body = trim0x(uncompressedPublicKey).toLowerCase();
-    if (body.length !== 130 || !body.startsWith('04')) {
-        throw new Error('Expected an uncompressed (65-byte, 0x04…) secp256k1 public key');
-    }
-    return SECP256K1_SPKI_DER_HEADER_HEX + body;
-}
-
-/**
- * DER-encode an ECDSA `(r, s)` signature as `SEQUENCE { INTEGER r, INTEGER s }`
- * (lowercase hex), via `@noble/secp256k1` so the ASN.1 encoding is not hand-rolled.
- * `r` / `s` are accepted as hex (with or without `0x`) and zero-padded to 32 bytes.
- */
-export function derEncodeSignature(r: string, s: string): string {
-    const compact = trim0x(r).padStart(64, '0') + trim0x(s).padStart(64, '0');
-    return secp256k1.Signature.fromCompact(compact).toDERHex();
-}

package/src/daml-serde.ts

@@ -1,171 +0,0 @@
-/**
- * Low-level serialization helpers that are byte-for-byte mirrors of the DAML
- * `Serde.Serde` module and the relevant `show` instances. Everything here operates
- * on **hex-encoded byte strings** (lowercase, no `0x` prefix) or DAML primitive
- * renderings, so an off-chain encoder produces the exact bytes the ledger verifies.
- *
- * Kept dependency-light (no ledger client) so encoding/signing SDKs can reuse it.
- */
-
-import { keccak_256 } from '@noble/hashes/sha3';
-
-import { bigIntToHex, bytesToHex, hexToBytes, trim0x } from '@layerzerolabs/common-encoding-utils';
-
-import type { IntLike } from './types';
-
-const HEX_DIGITS = /^[0-9a-fA-F]*$/;
-
-/** Convert an {@link IntLike} to a `bigint`, rejecting unsafe-integer `number`s. */
-export function toBigInt(value: IntLike, label = 'value'): bigint {
-    if (typeof value === 'bigint') return value;
-    // `number` only represents integers exactly up to MAX_SAFE_INTEGER; a larger
-    // value has already lost precision as a float, so reject it and require a
-    // bigint rather than encoding a silently-rounded oneSigId / nonce / Int.
-    if (!Number.isSafeInteger(value)) {
-        throw new Error(
-            `${label} must be a safe integer; pass a bigint for values beyond Number.MAX_SAFE_INTEGER, got ${value}`,
-        );
-    }
-    return BigInt(value);
-}
-
-/**
- * Unicode code-point count of a string — the measure DAML's `T.length` uses for
- * `lengthPrefix`. For the ASCII values encoded here this equals the byte count,
- * but we count code points (not UTF-16 units) so astral characters are measured
- * the same way DAML measures them.
- */
-export function codePointLength(value: string): number {
-    let count = 0;
-    for (const _ of value) count++;
-    return count;
-}
-
-/** DAML `show` of an `Int`: a base-10 string, negatives prefixed with `-`. */
-export function showInt(value: IntLike): string {
-    return toBigInt(value, 'int').toString(10);
-}
-
-/** DAML `show` of a `Bool`: `True` / `False` (capitalized). */
-export function showBool(value: boolean): string {
-    return value ? 'True' : 'False';
-}
-
-/**
- * DAML `show` of a `Decimal` (Numeric 10): a fixed-point decimal with trailing
- * zeros stripped but always at least one fractional digit (`1.0`, `2.5`, `100.0`).
- * Accepts a string (recommended, exact) or a JS number. Rejects scientific
- * notation and more than 10 fractional digits (DAML Decimal scale).
- */
-export function formatDamlDecimal(value: string | number): string {
-    const raw = (typeof value === 'number' ? numberToPlainString(value) : value).trim();
-
-    let negative = false;
-    let body = raw;
-    if (body.startsWith('-')) {
-        negative = true;
-        body = body.slice(1);
-    } else if (body.startsWith('+')) {
-        body = body.slice(1);
-    }
-
-    const [intPartRaw, fracPartRaw = '', ...rest] = body.split('.');
-    if (rest.length > 0 || !/^\d*$/.test(intPartRaw) || !/^\d*$/.test(fracPartRaw)) {
-        throw new Error(`Invalid decimal: ${raw}`);
-    }
-    if (fracPartRaw.length > 10) {
-        throw new Error(`Decimal exceeds 10 fractional digits (DAML Decimal scale): ${raw}`);
-    }
-
-    const intPart = intPartRaw.replace(/^0+(?=\d)/, '') || '0';
-    const fracPart = fracPartRaw.replace(/0+$/, '') || '0';
-    const isZero = intPart === '0' && fracPart === '0';
-    return `${negative && !isZero ? '-' : ''}${intPart}.${fracPart}`;
-}
-
-function numberToPlainString(value: number): string {
-    if (!Number.isFinite(value)) throw new Error(`Decimal must be finite, got ${value}`);
-    // Reject exponential notation rather than guessing the intended scale.
-    const asString = value.toString();
-    if (/e/i.test(asString)) {
-        throw new Error(`Pass decimals with many digits as strings, not numbers: ${asString}`);
-    }
-    return asString;
-}
-
-/**
- * Hex-encode strict-ASCII text, two lowercase hex digits per character. Rejects
- * code points >= 128: DAML encodes them as one byte while UTF-8 uses two, which
- * would produce different hashes, so non-ASCII is rejected rather than encoded
- * ambiguously (mirrors DAML `textToHex`).
- */
-export function textToHex(value: string): string {
-    let out = '';
-    for (const char of value) {
-        const cp = char.codePointAt(0)!;
-        if (cp >= 128) {
-            throw new Error(`Non-ASCII character (code point ${cp}) cannot be encoded`);
-        }
-        out += cp.toString(16).padStart(2, '0');
-    }
-    return out;
-}
-
-/**
- * Minimal (unpadded) lowercase hex of a non-negative integer: `0` for zero, no
- * leading zeros otherwise. Use `padLeft` on top when a fixed width is needed
- * (mirrors DAML `intToHex`).
- */
-export function intToHex(value: IntLike): string {
-    // `bigIntToHex` yields minimal `0x`-hex and rejects negatives; drop the prefix.
-    return trim0x(bigIntToHex(toBigInt(value, 'intToHex')));
-}
-
-/**
- * Left-pad a hex string with `0` to `targetLen` characters (right-aligned, e.g.
- * uint256). Throws if `value` is already longer than `targetLen`: an oversize
- * value must be rejected, never silently kept full-length, so fixed-width fields
- * stay positionally unambiguous (mirrors DAML `padLeft`).
- */
-export function padLeft(targetLen: number, value: string): string {
-    if (value.length > targetLen) {
-        throw new Error(`Value of length ${value.length} exceeds pad width ${targetLen}`);
-    }
-    return value.padStart(targetLen, '0');
-}
-
-/**
- * Assert that `value` is valid hex of exactly `expectedLen` characters (after
- * stripping an optional `0x`), returning the stripped lowercase hex. Unlike
- * padding, an off-length value is rejected rather than reshaped (mirrors DAML
- * `assertHexLength`).
- */
-export function assertHexLength(expectedLen: number, value: string): string {
-    const stripped = trim0x(value);
-    if (stripped.length % 2 !== 0 || stripped.length === 0 || !HEX_DIGITS.test(stripped)) {
-        throw new Error(`Invalid hex string: ${value}`);
-    }
-    if (stripped.length !== expectedLen) {
-        throw new Error(`Expected ${expectedLen} hex chars, got ${stripped.length}`);
-    }
-    return stripped.toLowerCase();
-}
-
-/** Whole seconds since the unix epoch for a `Date` (DAML `Time` → uint256 expiry). */
-export function timeToUnixSeconds(time: Date): bigint {
-    return BigInt(Math.floor(time.getTime() / 1000));
-}
-
-/**
- * keccak256 of the bytes denoted by hex string `h`, returned as 64 lowercase hex
- * chars (no `0x`). `h` must be a valid hex byte string (even length, `[0-9a-fA-F]`):
- * a malformed input is rejected, never hashed as raw text, matching DAML's
- * `keccak256 : BytesHex -> BytesHex` (which aborts on a malformed encoding).
- */
-export function keccak256Hex(h: string): string {
-    const stripped = trim0x(h);
-    if (stripped.length % 2 !== 0 || !HEX_DIGITS.test(stripped)) {
-        throw new Error(`keccak256 input is not a valid hex byte string: ${h}`);
-    }
-    return bytesToHex(keccak_256(hexToBytes(stripped)));
-}

package/src/deferredValue.ts

@@ -1,130 +0,0 @@
-import { z } from 'zod';
-
-import { NonRetryableError } from '@layerzerolabs/common-error-utils';
-
-/** Filter / authority token resolved to the ACS query (funding) party at refresh. */
-export const CANTON_DEFERRED_SENDER = 'sender' as const;
-export type CantonDeferredSender = typeof CANTON_DEFERRED_SENDER;
-
-export const cantonDeferredSenderSchema = z.literal(CANTON_DEFERRED_SENDER);
-
-export const isCantonDeferredSender = (value: unknown): value is CantonDeferredSender =>
-    value === CANTON_DEFERRED_SENDER;
-
-export const cantonRefreshPartyFilterSchema = z.union([
-    cantonDeferredSenderSchema,
-    z.object({ party: z.string() }),
-]);
-
-/** Non-empty list of parties that must all appear in created-event signatories. */
-export const cantonExpectedSignatoriesSchema = z
-    .array(z.union([cantonDeferredSenderSchema, z.string().min(1)]))
-    .nonempty();
-
-const cantonActiveContractRefFields = {
-    partyToFilter: cantonRefreshPartyFilterSchema,
-    /**
-     * Authority parties that must all be ledger signatories (authenticate-then-count).
-     * Use {@link CANTON_DEFERRED_SENDER} for the resolved funding/query party.
-     * Omitted on pre-existing persisted refs; refresh then defaults to the query
-     * party, except CIP-56 Amulet holdings (owner is not a signatory).
-     */
-    expectedSignatories: cantonExpectedSignatoriesSchema.optional(),
-    templateId: z.string(),
-    contractStateFilter: z.partialRecord(z.string(), z.any()).optional(),
-};
-
-export const cantonDeferredValueSchema = z.discriminatedUnion('type', [
-    z.object({ type: z.literal('senderParty') }),
-    z.object({
-        type: z.literal('activeContractId'),
-        ...cantonActiveContractRefFields,
-    }),
-    z.object({
-        type: z.literal('activeContractIds'),
-        ...cantonActiveContractRefFields,
-    }),
-    z.object({ type: z.literal('amuletRulesCid') }),
-    z.object({ type: z.literal('amuletContext') }),
-]);
-
-export type CantonRefreshPartyFilter = z.infer<typeof cantonRefreshPartyFilterSchema>;
-export type CantonExpectedSignatories = z.infer<typeof cantonExpectedSignatoriesSchema>;
-export type CantonDeferredValue = z.infer<typeof cantonDeferredValueSchema>;
-type CantonActiveContractIdRef = Omit<
-    Extract<CantonDeferredValue, { type: 'activeContractId' }>,
-    'type'
->;
-type CantonActiveContractIdsRef = Omit<
-    Extract<CantonDeferredValue, { type: 'activeContractIds' }>,
-    'type'
->;
-
-/**
- * Branded encoded form of a {@link CantonDeferredValue}: a sign-time reference
- * string that a resolver turns into a live contract id / party. Branding keeps it
- * distinct from a plain `string` so the ref-substitution stays type-checked.
- */
-export type CantonDeferredRef = string & { readonly __cantonDeferredRef: unique symbol };
-
-export const CANTON_DEFERRED_VALUE_PREFIX = '<<CANTON_DEFERRED:';
-export const CANTON_DEFERRED_VALUE_SUFFIX = '>>';
-
-/** True when `value` has deferred-ref framing, whether or not the payload parses. */
-export const isCantonDeferredSentinel = (value: unknown): value is string =>
-    typeof value === 'string' &&
-    value.startsWith(CANTON_DEFERRED_VALUE_PREFIX) &&
-    value.endsWith(CANTON_DEFERRED_VALUE_SUFFIX);
-
-export const encodeCantonDeferredValue = (value: CantonDeferredValue): CantonDeferredRef =>
-    `${CANTON_DEFERRED_VALUE_PREFIX}${JSON.stringify(value)}${CANTON_DEFERRED_VALUE_SUFFIX}` as CantonDeferredRef;
-
-export const parseCantonDeferredValue = (value: unknown): CantonDeferredValue | undefined => {
-    if (!isCantonDeferredSentinel(value)) {
-        return undefined;
-    }
-
-    try {
-        const parsedJson = JSON.parse(
-            value.slice(CANTON_DEFERRED_VALUE_PREFIX.length, -CANTON_DEFERRED_VALUE_SUFFIX.length),
-        );
-        return cantonDeferredValueSchema.parse(parsedJson);
-    } catch {
-        return undefined;
-    }
-};
-
-/**
- * Parse a deferred ref. Non-sentinels return `undefined`. A framed sentinel
- * that fails schema validation throws — callers must not treat corrupt refs
- * as plain strings.
- */
-export const parseCantonDeferredValueOrThrow = (
-    value: unknown,
-): CantonDeferredValue | undefined => {
-    const ref = parseCantonDeferredValue(value);
-    if (ref) return ref;
-    if (isCantonDeferredSentinel(value)) {
-        throw new NonRetryableError(`Invalid Canton deferred ref: ${value}`);
-    }
-    return undefined;
-};
-
-export const cantonSenderPartyRef = (): CantonDeferredRef =>
-    encodeCantonDeferredValue({ type: 'senderParty' });
-
-export const cantonActiveContractIdRef = (value: CantonActiveContractIdRef): CantonDeferredRef =>
-    encodeCantonDeferredValue({ type: 'activeContractId', ...value });
-
-export const cantonActiveContractIdsRef = (value: CantonActiveContractIdsRef): CantonDeferredRef =>
-    encodeCantonDeferredValue({ type: 'activeContractIds', ...value });
-
-export const cantonAmuletRulesCidRef = (): CantonDeferredRef =>
-    encodeCantonDeferredValue({ type: 'amuletRulesCid' });
-
-export const cantonAmuletContextRef = (): CantonDeferredRef =>
-    encodeCantonDeferredValue({ type: 'amuletContext' });
-
-/** Returns true if `value` is a valid Canton deferred-value sentinel. */
-export const isCantonPlaceholder = (value: string): boolean =>
-    parseCantonDeferredValue(value) !== undefined;