@layerzerolabs/common-canton 0.2.110 → 0.2.112

package/dist/transaction.d.ts

@@ -86,12 +86,66 @@ export declare const cantonTransactionSchema: z.ZodObject<{
         partyToSenderEntity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const cantonTransactionWithResultSchema: z.ZodObject<{
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    chainName: z.ZodString;
+    timestamps: z.ZodObject<{
+        created: z.ZodNumber;
+        nonceAcquired: z.ZodOptional<z.ZodNumber>;
+        signed: z.ZodOptional<z.ZodNumber>;
+        sent: z.ZodOptional<z.ZodNumber>;
+        confirmed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    type: z.ZodOptional<z.ZodString>;
+    parallelizingKey: z.ZodOptional<z.ZodString>;
+    populatedTransaction: z.ZodObject<{
+        unresolvedCommands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            createCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractId: z.ZodString;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            createAndExerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseByKeyCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractKey: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
+        unresolvedDisclosedContracts: z.ZodArray<z.ZodObject<{
+            templateId: z.ZodOptional<z.ZodString>;
+            contractId: z.ZodString;
+            createdEventBlob: z.ZodString;
+            synchronizerId: z.ZodString;
+        }, z.core.$strip>>;
+        actAs: z.ZodArray<z.ZodString>;
+        partyToSenderEntity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+} & {
+    result: typeof import("@layerzerolabs/common-chain-model").transactionResultSchema;
+}, z.core.$strip>;
 /**
  * Assigned transaction includes the inflight transaction data.
  */
 export declare const cantonAssignedTransactionSchema: z.ZodObject<{
     senderEntityName: z.ZodString;
-    nonce: z.ZodNumber;
+    nonce: z.ZodNumber /**
+     * Canton transaction schema for Daml Ledger API commands.
+     */;
     inflightTransaction: z.ZodOptional<z.ZodObject<{
         preparedTransaction: z.ZodString;
         preparedTransactionHash: z.ZodString;
@@ -200,7 +254,9 @@ export declare const cantonSignedTransactionSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     senderEntityName: z.ZodString;
-    nonce: z.ZodNumber;
+    nonce: z.ZodNumber /**
+     * Canton transaction schema for Daml Ledger API commands.
+     */;
     inflightTransaction: z.ZodOptional<z.ZodObject<{
         preparedTransaction: z.ZodString;
         preparedTransactionHash: z.ZodString;
@@ -264,16 +320,16 @@ export declare const cantonSignedTransactionSchema: z.ZodObject<{
  * Mined transaction with confirmation result.
  */
 export declare const cantonMinedTransactionSchema: z.ZodObject<{
-    result: z.ZodDiscriminatedUnion /** Hashing scheme version used */<[z.ZodObject<{
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"success">;
         minedTxHash: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"error">;
+        type: z.ZodLiteral /** Hashing scheme version used */<"error">;
         error: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"indeterminate">;
         meta: z.ZodAny;
-    }, z.core.$strip>], "type">;
+    }, z.core.$strip /** Command ID for tracking */>], "type">;
     inflightTransaction: z.ZodObject<{
         preparedTransaction: z.ZodString;
         preparedTransactionHash: z.ZodString;
@@ -329,7 +385,9 @@ export declare const cantonMinedTransactionSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     senderEntityName: z.ZodString;
-    nonce: z.ZodNumber;
+    nonce: z.ZodNumber /**
+     * Canton transaction schema for Daml Ledger API commands.
+     */;
     properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     chainName: z.ZodString;
     timestamps: z.ZodObject<{

package/dist/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAIjE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+B9B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;iBAKxC,CAAC;AAIH;;GAEG;AACH,eAAO,MAAM,uBAAuB;gBA5ChC,EAAA,WAAS,CACL,EAAA,SAAE,CAAC,EAAE,SAAS,EAAC,EAAG,MAAM;eAChB,EAAG,SAAS;gBAChB,EAAA,SAAS;iBACb,EAAA,SACN;uBAEM,EAAA,WAAS,CAAC,EAAE,SAAS;gBACjB,EAAE,WAAW,CAAC,EAAE,SAC3B;cAAgB,EAAG,WAAW,CAAC,EAAE,SAC3B;mBAAqB,EAChB,WAAF,CAAE,EAAC,SAAS;OAAS,EAAG,IACjC,CAAO,MAAA;UAEJ,EAAA,WAAU,CACN,EAAA,SAAG;sBAAwB,EAAG,WAClC,CAAQ,EAAA,SAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0Cd,CAAC;AAEH,eAAO,MAAM,iCAAiC;gBA5D1C,EAAA,WAAS,CACL,EAAA,SAAE,CAAC,EAAE,SAAS,EAAC,EAAG,MAAM;eAChB,EAAG,SAAS;gBAChB,EAAA,SAAS;iBACb,EAAA,SACN;uBAEM,EAAA,WAAS,CAAC,EAAE,SAAS;gBACjB,EAAE,WAAW,CAAC,EAAE,SAC3B;cAAgB,EAAG,WAAW,CAAC,EAAE,SAC3B;mBAAqB,EAChB,WAAF,CAAE,EAAC,SAAS;OAAS,EAAG,IACjC,CAAO,MAAA;UAEJ,EAAA,WAAU,CACN,EAAA,SAAG;sBAAwB,EAAG,WAClC,CAAQ,EAAA,SAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6C6C,CAAC;AAoB9D;;GAEG;AACH,eAAO,MAAM,+BAA+B;sBA/C5C,EAAE,SAEI;WAAY,EAAG,SAErB,CAAA;;OAEG;;;;;;;;;;;gBA3CC,EAAA,WAAS,CACL,EAAA,SAAE,CAAC,EAAE,SAAS,EAAC,EAAG,MAAM;eAChB,EAAG,SAAS;gBAChB,EAAA,SAAS;iBACb,EAAA,SACN;uBAEM,EAAA,WAAS,CAAC,EAAE,SAAS;gBACjB,EAAE,WAAW,CAAC,EAAE,SAC3B;cAAgB,EAAG,WAAW,CAAC,EAAE,SAC3B;mBAAqB,EAChB,WAAF,CAAE,EAAC,SAAS;OAAS,EAAG,IACjC,CAAO,MAAA;UAEJ,EAAA,WAAU,CACN,EAAA,SAAG;sBAAwB,EAAG,WAClC,CAAQ,EAAA,SAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuEd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAvD1C,EAAE,SAEI;WAAY,EAAG,SAErB,CAAA;;OAEG;;;;;;;;;;;gBA3CC,EAAA,WAAS,CACL,EAAA,SAAE,CAAC,EAAE,SAAS,EAAC,EAAG,MAAM;eAChB,EAAG,SAAS;gBAChB,EAAA,SAAS;iBACb,EAAA,SACN;uBAEM,EAAA,WAAS,CAAC,EAAE,SAAS;gBACjB,EAAE,WAAW,CAAC,EAAE,SAC3B;cAAgB,EAAG,WAAW,CAAC,EAAE,SAC3B;mBAAqB,EAChB,WAAF,CAAE,EAAC,SAAS;OAAS,EAAG,IACjC,CAAO,MAAA;UAEJ,EAAA,WAAU,CACN,EAAA,SAAG;sBAAwB,EAAG,WAClC,CAAQ,EAAA,SAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiGd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,4BAA4B;YAtDjC,EAAI,qBAAoB,EAAE,EAAE,SAChC;cAAgB,EAAG,UAAU;qBACJ,EAAG,SAAS;OAAQ,EAAG,IAAI,CAAC,MACxD,GAAG,EAAE,SAAS;cAAgB,EAAG,UAC/B,CAAC,kCAAkC;eAAV,EAAG,SAC9B;OAAQ,EAAG,IAAI,CAAC,MAAM,GAAG,EAAE,SAC1B;cAAgB,EAAG,UAAU;cACd,EAAG,MAAM;OAAQ,EAC9B,IAAA,CAAC,MACF,CAAC,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBApClC,EAAE,SAEI;WAAY,EAAG,SAErB,CAAA;;OAEG;gBA3CC,EAAA,WAAS,CACL,EAAA,SAAE,CAAC,EAAE,SAAS,EAAC,EAAG,MAAM;eAChB,EAAG,SAAS;gBAChB,EAAA,SAAS;iBACb,EAAA,SACN;uBAEM,EAAA,WAAS,CAAC,EAAE,SAAS;gBACjB,EAAE,WAAW,CAAC,EAAE,SAC3B;cAAgB,EAAG,WAAW,CAAC,EAAE,SAC3B;mBAAqB,EAChB,WAAF,CAAE,EAAC,SAAS;OAAS,EAAG,IACjC,CAAO,MAAA;UAEJ,EAAA,WAAU,CACN,EAAA,SAAG;sBAAwB,EAAG,WAClC,CAAQ,EAAA,SAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyGd,CAAC;AAIH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC/D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAC/E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAC3E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAIzE,MAAM,MAAM,2BAA2B,GAAG,SAAS,CAAC,QAAQ,EAAE,WAAW,GAAG,YAAY,CAAC,CAAC;AAE1F,eAAO,MAAM,sBAAsB,GAC/B,WAAW,MAAM,EACjB,IAAI,2BAA2B,KAChC,OAAO,CAAC,QAAQ,CAQlB,CAAC"}

package/dist/transaction.js

@@ -1,4 +1,4 @@
-export { buildCantonTransaction, cantonAssignedTransactionSchema, cantonCommandSchema, cantonDisclosedContractSchema, cantonMinedTransactionSchema, cantonSignedTransactionSchema, cantonTransactionSchema } from './PSB6BQFH.js';
+export { buildCantonTransaction, cantonAssignedTransactionSchema, cantonCommandSchema, cantonDisclosedContractSchema, cantonMinedTransactionSchema, cantonSignedTransactionSchema, cantonTransactionSchema, cantonTransactionWithResultSchema } from './EYLCZMM4.js';
 import './VUOMXK5T.js';
 //# sourceMappingURL=transaction.js.map
 //# sourceMappingURL=transaction.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/common-canton",
-  "version": "0.2.110",
+  "version": "0.2.112",
   "private": false,
   "description": "Canton VM client and utilities",
   "license": "MIT",
@@ -18,12 +18,15 @@
     "@daml/types": "3.4.8",
     "@grpc/grpc-js": "^1.12.0",
     "@mojotech/json-type-validation": "^3.1.0",
+    "@noble/hashes": "^1.8.0",
+    "@noble/secp256k1": "1.7.1",
     "@protobuf-ts/grpc-transport": "^2.9.4",
     "es-toolkit": "^1.39.10",
     "zod": "4.3.5",
-    "@layerzerolabs/common-error-utils": "0.2.110",
-    "@layerzerolabs/common-chain-model": "0.2.110",
-    "@layerzerolabs/typescript-utils": "0.2.110"
+    "@layerzerolabs/common-chain-model": "0.2.112",
+    "@layerzerolabs/common-encoding-utils": "0.2.112",
+    "@layerzerolabs/typescript-utils": "0.2.112",
+    "@layerzerolabs/common-error-utils": "0.2.112"
   },
   "devDependencies": {
     "@types/node": "^22.18.6",
@@ -32,12 +35,12 @@
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
     "vitest": "^3.2.6",
-    "@layerzerolabs/eslint-configuration": "^0.2.110",
-    "@layerzerolabs/tsup-configuration": "0.2.110",
-    "@layerzerolabs/typescript-configuration": "0.2.110",
-    "@layerzerolabs/vm-tooling-canton": "0.2.110",
-    "@layerzerolabs/ver-signer-adapter": "0.2.110",
-    "@layerzerolabs/vitest-configuration": "0.2.110"
+    "@layerzerolabs/eslint-configuration": "^0.2.112",
+    "@layerzerolabs/tsup-configuration": "0.2.112",
+    "@layerzerolabs/typescript-configuration": "0.2.112",
+    "@layerzerolabs/ver-signer-adapter": "0.2.112",
+    "@layerzerolabs/vitest-configuration": "0.2.112",
+    "@layerzerolabs/vm-tooling-canton": "0.2.112"
   },
   "publishConfig": {
     "access": "restricted",

package/src/amulet.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+
+const AMULET_DECIMAL_PLACES = 10n;
+
+const amuletPayloadSchema = z.object({
+    amount: z.object({ initialAmount: z.string() }),
+});
+
+/**
+ * Parses a DAML Decimal string (e.g. `"42.5000000000"`, `"-1.5"`) into a bigint
+ * scaled by 10^10. Fractional digits beyond ten places are truncated towards zero.
+ */
+export const parseAmuletDecimal = (value: string): bigint => {
+    const [integer, fraction = ''] = value.replace(/^-/, '').split('.');
+
+    return (
+        (value.startsWith('-') ? -1n : 1n) *
+        (BigInt(integer || '0') * 10n ** AMULET_DECIMAL_PLACES +
+            BigInt(
+                fraction
+                    .slice(0, Number(AMULET_DECIMAL_PLACES))
+                    .padEnd(Number(AMULET_DECIMAL_PLACES), '0'),
+            ))
+    );
+};
+
+export const parseAmuletAmount = (createArgument: unknown): bigint =>
+    parseAmuletDecimal(amuletPayloadSchema.parse(createArgument).amount.initialAmount);

package/src/client/canton-client.ts

@@ -892,7 +892,43 @@ export class CantonClient implements ICantonClient {
         templateIds: string[],
         opts?: { limit?: number },
     ): Promise<JsActiveContract[]> {
-        const cumulativeFilter = this.#buildCumulativeFilters(templateIds);
+        return this.#fetchActiveContracts(
+            parties,
+            offset,
+            this.#buildCumulativeFilters(templateIds),
+            opts,
+        );
+    }
+
+    /**
+     * Query active contracts visible to any of the given parties that implement
+     * the given interfaces.
+     *
+     * @param parties - Parties to query as (for visibility)
+     * @param offset - Ledger offset for the snapshot
+     * @param interfaceIds - Interface IDs to filter by (e.g. "#package:Module:Interface")
+     * @param opts.limit - Maximum number of contracts to return
+     */
+    async queryActiveContractsByInterface(
+        parties: string[],
+        offset: number,
+        interfaceIds: string[],
+        opts?: { limit?: number },
+    ): Promise<JsActiveContract[]> {
+        return this.#fetchActiveContracts(
+            parties,
+            offset,
+            this.#buildInterfaceCumulativeFilters(interfaceIds),
+            opts,
+        );
+    }
+
+    async #fetchActiveContracts(
+        parties: string[],
+        offset: number,
+        cumulativeFilter: CumulativeFilter[],
+        opts?: { limit?: number },
+    ): Promise<JsActiveContract[]> {
         const filtersByParty = Object.fromEntries(
             parties.map((party) => [party, { cumulative: cumulativeFilter }]),
         );
@@ -982,6 +1018,29 @@ export class CantonClient implements ICantonClient {
         ];
     }
 
+    /**
+     * Build cumulative filters for interface-based ACS queries.
+     * If interfaceIds provided, filters by those interfaces; otherwise uses wildcard.
+     */
+    #buildInterfaceCumulativeFilters(interfaceIds?: string[]): CumulativeFilter[] {
+        if (interfaceIds?.length) {
+            return interfaceIds.map((interfaceId) => ({
+                identifierFilter: {
+                    interfaceFilter: {
+                        value: {
+                            interfaceId,
+                            includeInterfaceView: true,
+                            includeCreatedEventBlob: false,
+                        },
+                    },
+                },
+            }));
+        }
+        return [
+            { identifierFilter: { wildcardFilter: { value: { includeCreatedEventBlob: false } } } },
+        ];
+    }
+
     /**
      * Build the standard update format for fetching transactions.
      */

package/src/client/interface.ts

@@ -269,6 +269,22 @@ export interface ICantonClient {
         opts?: { limit?: number },
     ): Promise<JsActiveContract[]>;
 
+    /**
+     * Query active contracts visible to any of the given parties that implement
+     * the given interfaces.
+     *
+     * @param parties - Parties to query as (for visibility)
+     * @param offset - Ledger offset to query at
+     * @param interfaceIds - Interface IDs to filter by (e.g., "#package:Module:Interface")
+     * @param opts.limit - Maximum number of contracts to return
+     */
+    queryActiveContractsByInterface(
+        parties: string[],
+        offset: number,
+        interfaceIds: string[],
+        opts?: { limit?: number },
+    ): Promise<JsActiveContract[]>;
+
     /**
      * Stream updates from a given offset.
      *

package/src/client/utils.ts

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 
+import { SECP256K1_SPKI_DER_HEADER } from '../crypto';
 import type { CantonTransaction, CantonUpdate } from './interface';
 
 /**
@@ -10,12 +11,6 @@ export function extractTransactions(updates: CantonUpdate[]): CantonTransaction[
     return updates.flatMap((update) => ('Transaction' in update ? [update.Transaction.value] : []));
 }
 
-// DER header for secp256k1 SubjectPublicKeyInfo (23 bytes).
-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,
-]);
-
 const HASH_PURPOSE_PUBLIC_KEY_FINGERPRINT = 12;
 const MULTIHASH_SHA256_PREFIX = new Uint8Array([0x12, 0x20]);
 

package/src/crypto.ts

@@ -0,0 +1,42 @@
+/**
+ * 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

@@ -0,0 +1,182 @@
+/**
+ * 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 { z } from 'zod';
+
+import { bigIntToHex, bytesToHex, hexToBytes, trim0x } from '@layerzerolabs/common-encoding-utils';
+
+/**
+ * A 64-bit integer field (oneSigId / nonce / threshold / count / signed `Int`).
+ * A `number` must be a safe integer — larger values have already lost precision as
+ * a float, so a bigint is required (mirrors the {@link toBigInt} runtime guard).
+ */
+export const IntLikeSchema = z
+    .union([z.bigint(), z.number()])
+    .refine((value) => typeof value === 'bigint' || Number.isSafeInteger(value), {
+        message: 'number must be a safe integer; pass a bigint for values beyond MAX_SAFE_INTEGER',
+    });
+export type IntLike = z.infer<typeof IntLikeSchema>;
+
+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)));
+}