@layerzerolabs/common-canton 1.2.84 → 1.2.85

package/dist/transaction.d.ts.map

@@ -1 +1 @@
-{"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;AAMjE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+B9B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;iBAKxC,CAAC;AAIH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBlC,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBACe,CAAC;AAoB9D;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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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;AAMjE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+B9B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;iBAKxC,CAAC;AAIH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBlC,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBACe,CAAC;AAoB9D;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG1C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBxC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGvC,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC/D,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC,sBAAsB,CAAC,CAAC;AAC1E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC;AACpD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,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,cACpB,MAAM,MACb,2BAA2B,KAChC,OAAO,CAAC,QAAQ,CAQlB,CAAC"}

package/dist/trusted-origin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trusted-origin.d.ts","sourceRoot":"","sources":["../src/trusted-origin.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,sBAAsB,GAAI,gBAAgB,OAAO,EAAE,WAAW,MAAM,KAAG,OASnF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GAC/B,SAAS;IAAE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAC5C,qBAAqB,SAAS,MAAM,EAAE,KACvC,OAIF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC1B,SAAS;IAAE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAC5C,eAAe,MAAM,KACtB,OAA2D,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GACxB,SAAS;IAAE,cAAc,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EACtE,eAAe,MAAM,EACrB,qBAAqB,MAAM,KAC5B,OAKF,CAAC"}
+{"version":3,"file":"trusted-origin.d.ts","sourceRoot":"","sources":["../src/trusted-origin.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,sBAAsB,mBAAoB,OAAO,aAAa,MAAM,KAAG,OASnF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,YACtB;IAAE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,uBACvB,SAAS,MAAM,EAAE,KACvC,OAIF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,YACjB;IAAE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,iBAC7B,MAAM,KACtB,OAA2D,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,YACf;IAAE,cAAc,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,iBACvD,MAAM,uBACA,MAAM,KAC5B,OAKF,CAAC"}

package/dist/types.d.ts

@@ -40,9 +40,9 @@ export type SubmitResult = {
  * Wait / Reconciliation Types
  */
 export declare const CommandStatus: {
-    readonly Accepted: "accepted";
-    readonly Rejected: "rejected";
-    readonly Timeout: "timeout";
+    readonly Accepted: 'accepted';
+    readonly Rejected: 'rejected';
+    readonly Timeout: 'timeout';
 };
 export type CommandStatus = (typeof CommandStatus)[keyof typeof CommandStatus];
 export type WaitAccepted = {

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/common-canton",
-  "version": "1.2.84",
+  "version": "1.2.85",
   "private": false,
   "description": "Canton VM client and utilities",
   "license": "MIT",
@@ -32,10 +32,10 @@
     "@canton-network/core-ledger-proto": "^1.7.0",
     "@daml/types": "3.4.8",
     "@grpc/grpc-js": "^1.14.5",
-    "@layerzerolabs/common-chain-model": "1.2.84",
-    "@layerzerolabs/common-encoding-utils": "1.2.84",
-    "@layerzerolabs/common-error-utils": "1.2.84",
-    "@layerzerolabs/typescript-utils": "1.2.84",
+    "@layerzerolabs/common-chain-model": "1.2.85",
+    "@layerzerolabs/common-encoding-utils": "1.2.85",
+    "@layerzerolabs/common-error-utils": "1.2.85",
+    "@layerzerolabs/typescript-utils": "1.2.85",
     "@mojotech/json-type-validation": "^3.1.0",
     "@noble/hashes": "^1.8.0",
     "@noble/secp256k1": "1.7.1",
@@ -46,15 +46,15 @@
     "zod": "4.3.5"
   },
   "devDependencies": {
-    "@layerzerolabs/eslint-configuration": "^1.2.84",
-    "@layerzerolabs/tsup-configuration": "1.2.84",
-    "@layerzerolabs/typescript-configuration": "1.2.84",
-    "@layerzerolabs/vitest-configuration": "1.2.84",
-    "@layerzerolabs/vm-tooling-canton": "1.2.84",
+    "@layerzerolabs/eslint-configuration": "^1.2.85",
+    "@layerzerolabs/tsup-configuration": "1.2.85",
+    "@layerzerolabs/typescript-configuration": "1.2.85",
+    "@layerzerolabs/vitest-configuration": "1.2.85",
+    "@layerzerolabs/vm-tooling-canton": "1.2.85",
     "@vitest/coverage-v8": "4.1.10",
     "eslint": "9.39.1",
     "tsup": "^8.4.0",
-    "typescript": "^6.0.3",
+    "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },
   "publishConfig": {

package/dist/43KGTQUU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/refresh/callback-burn-mint.ts"],"names":["DELEGATE_TEMPLATE","HOLDING_INTERFACE","MINT_FACTORY_PATH","applyDelegate","sdk","informee","offset","factory","instrumentId","oappAdmin","contracts","queryActiveContracts","templateIds","includeCreatedEventBlob","matches","filter","createdEvent","payload","createArgument","admin","id","delegate","isTrustedOrigin","length","Error","match","burnMintFactoryCid","factoryId","contractId","choiceContext","disclosedContracts","callbackDisclosure","resolveBurnMintCallbackContext","appUid","mintEscrow","receivers","environment","urls","discoveryUrlsForAppUid","discoveryUrl","parsed","assertSafeRegistryUrl","label","registryMintFactory","postFactoryContext","URL","origin","toString","inputHoldingCids","outputs","owner","amount","probeName","mintFactory","issuerCredentials","discloseUtilityCredentials","values","holdings","fetchCallbackHoldings","map","holding","firstAmount","callbackInterfaceView","find","transferFactory","fetchMergedTransferFactoryContext","sender","senderCredentials","burnMintExtraArgs","burnMintOutputContext","transferFactoryCid","assetTransferContext"],"mappings":"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","file":"43KGTQUU.js","sourcesContent":["import type { InstrumentId } from '../client/amulet';\nimport type { CantonSdk } from '../sdk';\nimport type { CantonDisclosedContract } from '../transaction';\nimport { isTrustedOrigin } from '../trusted-origin';\nimport { callbackDisclosure, callbackInterfaceView } from './callback-contracts';\nimport {\n    assertSafeRegistryUrl,\n    discloseUtilityCredentials,\n    discoveryUrlsForAppUid,\n    fetchCallbackHoldings,\n    fetchMergedTransferFactoryContext,\n    postFactoryContext,\n    type TransferFactoryContext,\n} from './registry-context';\n\nconst DELEGATE_TEMPLATE = '#layerzero-burn-mint-adapter:BurnMintDelegate:BurnMintDelegate';\nconst HOLDING_INTERFACE = '#splice-api-token-holding-v1:Splice.Api.Token.HoldingV1:Holding';\nconst MINT_FACTORY_PATH = 'api/utilities/v0/registry/burn-mint-instruction/v0/burn-mint-factory';\ntype DelegatePayload = { instrumentId: InstrumentId; delegate: string; burnMintFactoryCid: string };\n\nconst applyDelegate = async (\n    sdk: CantonSdk,\n    informee: string,\n    offset: number,\n    factory: TransferFactoryContext,\n    instrumentId: InstrumentId,\n    oappAdmin: string,\n): Promise<TransferFactoryContext> => {\n    const contracts = await sdk.queryActiveContracts(informee, offset, {\n        templateIds: [DELEGATE_TEMPLATE],\n        includeCreatedEventBlob: true,\n    });\n    const matches = contracts.filter(({ createdEvent }) => {\n        const payload = createdEvent.createArgument as DelegatePayload;\n        return (\n            payload.instrumentId?.admin === instrumentId.admin &&\n            payload.instrumentId.id === instrumentId.id &&\n            payload.delegate === oappAdmin &&\n            isTrustedOrigin(createdEvent, instrumentId.admin, 'instrumentId.admin')\n        );\n    });\n    if (matches.length > 1) {\n        throw new Error(\n            `Multiple BurnMintDelegate contracts for instrument ${instrumentId.admin}/${instrumentId.id} delegate=${oappAdmin} (${matches.length})`,\n        );\n    }\n    const match = matches[0];\n    if (!match) {\n        if (oappAdmin !== instrumentId.admin) {\n            throw new Error(\n                `No BurnMintDelegate for instrument ${instrumentId.admin}/${instrumentId.id} delegate=${oappAdmin}; the adapter admin is not the instrument admin`,\n            );\n        }\n        return factory;\n    }\n    const payload = match.createdEvent.createArgument as DelegatePayload;\n    if (payload.burnMintFactoryCid !== factory.factoryId) {\n        throw new Error(\n            `BurnMintDelegate ${match.createdEvent.contractId} points at burn-mint factory ${payload.burnMintFactoryCid}, but the registry returned ${factory.factoryId}`,\n        );\n    }\n    return {\n        factoryId: match.createdEvent.contractId,\n        choiceContext: factory.choiceContext,\n        disclosedContracts: [callbackDisclosure(match), ...factory.disclosedContracts],\n    };\n};\n\nexport const resolveBurnMintCallbackContext = async ({\n    sdk,\n    informee,\n    appUid,\n    oappAdmin,\n    mintEscrow,\n    instrumentId,\n    offset,\n    receivers,\n    environment,\n}: {\n    sdk: CantonSdk;\n    informee: string;\n    appUid: string;\n    oappAdmin: string;\n    mintEscrow: string;\n    instrumentId: InstrumentId;\n    offset: number;\n    receivers: string[];\n    environment?: string;\n}): Promise<{\n    disclosedContracts: CantonDisclosedContract[];\n    transferFactoryCid?: string;\n    assetTransferContext?: Record<string, unknown>;\n    burnMintFactoryCid?: string;\n    burnMintExtraArgs?: Record<string, unknown>;\n    burnMintOutputContext?: Record<string, unknown>;\n}> => {\n    if (receivers.length === 0) return { disclosedContracts: [] };\n    const urls = await discoveryUrlsForAppUid(sdk, informee, offset, appUid);\n    if (urls.length !== 1) {\n        throw new Error(\n            `Expected exactly one discovery URL for appUid ${appUid}, found ${urls.length}`,\n        );\n    }\n    const discoveryUrl = urls[0]!;\n    const parsed = assertSafeRegistryUrl(discoveryUrl, {\n        environment,\n        label: 'burn-mint-factory utilities URL',\n    });\n    const registryMintFactory = await postFactoryContext(\n        new URL(MINT_FACTORY_PATH, `${parsed.origin}/`).toString(),\n        { instrumentId, inputHoldingCids: [], outputs: [{ owner: mintEscrow, amount: '1' }] },\n        { probeName: 'burn-mint-factory' },\n    );\n    const mintFactory = await applyDelegate(\n        sdk,\n        informee,\n        offset,\n        registryMintFactory,\n        instrumentId,\n        oappAdmin,\n    );\n    const issuerCredentials = await discloseUtilityCredentials(\n        sdk,\n        mintFactory.choiceContext.values['utility.digitalasset.com/issuer-credentials'],\n        mintEscrow,\n        'issuer',\n    );\n    const holdings = await fetchCallbackHoldings(sdk, mintEscrow, offset, instrumentId);\n    const inputHoldingCids = holdings.map((holding) => holding.createdEvent.contractId);\n    const firstAmount = holdings\n        .map((holding) => callbackInterfaceView(holding, HOLDING_INTERFACE)?.amount)\n        .find((amount): amount is string => amount != null && amount !== '0');\n    const transferFactory = await fetchMergedTransferFactoryContext(discoveryUrl, instrumentId, {\n        environment,\n        inputHoldingCids,\n        sender: mintEscrow,\n        amount: firstAmount ?? '0',\n        receivers,\n    });\n    const senderCredentials = await discloseUtilityCredentials(\n        sdk,\n        transferFactory.choiceContext.values['utility.digitalasset.com/sender-credentials'],\n        mintEscrow,\n        'sender',\n    );\n    return {\n        disclosedContracts: [\n            ...mintFactory.disclosedContracts,\n            ...issuerCredentials,\n            ...transferFactory.disclosedContracts,\n            ...senderCredentials,\n        ],\n        burnMintFactoryCid: mintFactory.factoryId,\n        burnMintExtraArgs: mintFactory.choiceContext.values,\n        burnMintOutputContext: {},\n        transferFactoryCid: transferFactory.factoryId,\n        assetTransferContext: transferFactory.choiceContext.values,\n    };\n};\n"]}

package/dist/5W44RCVL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sdk/canton-sdk.ts"],"names":["CantonSdk","client","event","contractId","undefined","templateId","CantonProtocolError","createArgument","payload","buildCreate","template","packageId","parts","replace","split","createCommand","join","createArguments","encode","buildExercise","choice","args","encodedArgs","argumentEncode","exerciseCommand","choiceName","choiceArgument","submit","actors","commands","opts","prepareForSigning","submitSigned","prepared","signatures","waitForCommand","commandId","get","parties","fetchContractById","fetchContractEvent","fetchTransaction","updateId","fetchTransactionByUpdateId","fetchTransactionByOffset","offset","fetchEventsByContractId","createDisclosure","connectedSynchronizers","uploadDar","dar","validateDar","listParties","listUserParties","allocateParty","partyIdHint","getPackageId","packageName","getLedgerEndOffset","queryActiveContracts","party","normalizeActiveContract","contract","e","createdEvent","synchronizerId","queryActiveContractsByParties","templateIds","queryActiveContractsByInterface","interfaceIds","queryActiveContractsForParties","templateFilter","apiOpts","perPartyResults","Promise","all","map","partyId","seen","Set","result","contracts","c","cid","has","add","normalized","push"],"mappings":"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","file":"5W44RCVL.js","sourcesContent":["import type { Choice, ContractId, Party, Template } from '@daml/types';\n\nimport type { CantonTransaction, ICantonClient } from '../client/index';\nimport { CantonProtocolError } from '../errors';\nimport type {\n    ArchivedEvent,\n    Command,\n    CreatedEvent,\n    DisclosedContract,\n    JsActiveContract,\n} from '../open-api/models';\nimport type { CantonDisclosedContract } from '../transaction';\nimport type {\n    Contract,\n    ExternalSignature,\n    NormalizedActiveContract,\n    PreparedTransaction,\n    SubmitActors,\n    SubmitResult,\n    WaitOptions,\n    WaitResult,\n} from '../types';\n\n/**\n * High-level SDK for Canton/DAML contract operations.\n *\n * Users interact with this SDK, not CantonClient directly.\n *\n * @example\n * ```ts\n * import { CantonClient, CantonSdk } from '@layerzerolabs/common-canton';\n *\n * const client = new CantonClient(config, userId);\n * const sdk = new CantonSdk(client);\n *\n * await sdk.submit({ actAs: [party] }, [cmd]);\n * ```\n */\nexport class CantonSdk {\n    readonly #client: ICantonClient;\n\n    constructor(client: ICantonClient) {\n        this.#client = client;\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Private Helpers\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Validate and extract contract fields from a CreatedEvent.\n     * Returns undefined if event is undefined (contract not found).\n     */\n    #validateContractEvent<T extends object>(\n        event: { templateId?: string; contractId?: string; createArgument?: unknown } | undefined,\n        contractId: ContractId<T>,\n    ): Contract<T> | undefined {\n        if (!event) return undefined;\n\n        if (!event.templateId) {\n            throw new CantonProtocolError('Contract response missing templateId', {\n                contractId,\n            });\n        }\n        if (!event.contractId) {\n            throw new CantonProtocolError('Contract response missing contractId', {\n                contractId,\n            });\n        }\n        if (event.createArgument === undefined) {\n            throw new CantonProtocolError('Contract response missing createArgument', {\n                contractId,\n            });\n        }\n        return {\n            templateId: event.templateId,\n            contractId: event.contractId as ContractId<T>,\n            payload: event.createArgument as T,\n        };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Command Builders\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Build a create command using a generated DAML template.\n     *\n     * @param template The generated DAML template (e.g., StateCommitment)\n     * @param payload The contract payload\n     * @param packageId The package ID from the generated package's index.js\n     */\n    buildCreate<T extends object, K, I extends string>(\n        template: Template<T, K, I>,\n        payload: T,\n        packageId: string,\n    ): Command {\n        // Generated templateId format: '#packageName:Module:Entity'\n        // Canton API needs: 'packageId:Module:Entity'\n        const parts = template.templateId.replace(/^#/, '').split(':');\n        parts[0] = packageId;\n\n        return {\n            createCommand: {\n                templateId: parts.join(':'),\n                createArguments: template.encode(payload),\n            },\n        };\n    }\n\n    /**\n     * Build an exercise command using a generated DAML choice.\n     *\n     * @param choice The generated DAML choice (e.g., StateCommitment.Archive)\n     * @param contractId The contract ID to exercise on\n     * @param args The choice arguments\n     * @param packageId The package ID from the generated package's index.js\n     */\n    buildExercise<T extends object, C, R, K>(\n        choice: Choice<T, C, R, K>,\n        contractId: ContractId<T>,\n        args: C,\n        packageId: string,\n    ): Command {\n        // Generated templateId format: '#packageName:Module:Entity'\n        // Canton API needs: 'packageId:Module:Entity'\n        const parts = choice.template().templateId.replace(/^#/, '').split(':');\n        parts[0] = packageId;\n\n        const encodedArgs = choice.argumentEncode(args);\n\n        return {\n            exerciseCommand: {\n                templateId: parts.join(':'),\n                contractId,\n                choice: choice.choiceName,\n                choiceArgument: encodedArgs,\n            },\n        };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Submission (networked)\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Submit commands to the ledger.\n     */\n    submit(\n        actors: SubmitActors,\n        commands: Command[],\n        opts?: { disclosedContracts?: DisclosedContract[]; commandId?: string },\n    ): Promise<SubmitResult> {\n        return this.#client.submit(actors, commands, opts);\n    }\n\n    /**\n     * Prepare commands for off-chain signing by external parties.\n     */\n    prepareForSigning(\n        actors: SubmitActors,\n        commands: Command[],\n        opts?: { disclosedContracts?: DisclosedContract[]; commandId?: string },\n    ): Promise<PreparedTransaction> {\n        return this.#client.prepareForSigning(actors, commands, opts);\n    }\n\n    /**\n     * Submit a pre-signed transaction (external party flow).\n     */\n    submitSigned(\n        prepared: PreparedTransaction,\n        signatures: ExternalSignature[],\n    ): Promise<SubmitResult> {\n        return this.#client.submitSigned(prepared, signatures);\n    }\n\n    /**\n     * Wait for a command to be accepted or rejected.\n     */\n    waitForCommand(commandId: string, opts: WaitOptions): Promise<WaitResult> {\n        return this.#client.waitForCommand(commandId, opts);\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Queries\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Fetch a specific contract by ID.\n     * Returns undefined if archived or not visible.\n     *\n     * @param contractId The contract ID to fetch\n     * @param parties Parties to use for visibility filtering\n     */\n    async get<T extends object>(\n        contractId: ContractId<T>,\n        parties: Party[],\n    ): Promise<Contract<T> | undefined> {\n        const event = await this.#client.fetchContractById(contractId, parties);\n        return this.#validateContractEvent(event, contractId);\n    }\n\n    /**\n     * Fetch a live contract's created event by ID, with the views of `interfaceIds` when given:\n     * one point lookup that returns the payload, the interface views and the signatories.\n     */\n    fetchContractEvent(\n        contractId: string,\n        parties: Party[],\n        opts?: { interfaceIds?: string[] },\n    ): Promise<CreatedEvent | undefined> {\n        return this.#client.fetchContractById(contractId as ContractId<unknown>, parties, opts);\n    }\n\n    /**\n     * Fetch an update (transaction) by its ID.\n     *\n     * Use this to get created contract IDs after a command is accepted.\n     * The updateId comes from WaitResult.updateId.\n     *\n     * @param updateId The update ID from WaitResult\n     * @param parties Parties to filter events\n     * @returns Parsed update with events\n     *\n     * @example\n     * ```ts\n     * const waitResult = await sdk.waitForCommand(commandId, opts);\n     * if (waitResult.status === 'accepted') {\n     *     const tx = await sdk.fetchTransaction(waitResult.updateId, [party]);\n     *     const createdIds = (tx.events ?? [])\n     *         .filter(e => 'CreatedEvent' in e)\n     *         .map(e => e.CreatedEvent.contractId);\n     * }\n     * ```\n     */\n    fetchTransaction(updateId: string, parties: string[]): Promise<CantonTransaction> {\n        return this.#client.fetchTransactionByUpdateId(updateId, parties);\n    }\n\n    /**\n     * Fetch a transaction by its offset.\n     *\n     * @param offset The ledger offset\n     * @param parties Parties to filter events\n     * @returns Parsed transaction with events and timestamps\n     */\n    fetchTransactionByOffset(offset: number, parties: string[]): Promise<CantonTransaction> {\n        return this.#client.fetchTransactionByOffset(offset, parties);\n    }\n\n    /**\n     * Fetch both the created and archived events for a contract by ID.\n     *\n     * @param contractId - The contract ID to look up\n     * @param parties - Parties to use for visibility filtering\n     */\n    fetchEventsByContractId(\n        contractId: string,\n        parties: string[],\n    ): Promise<{ created: CreatedEvent | undefined; archived: ArchivedEvent | undefined }> {\n        return this.#client.fetchEventsByContractId(contractId, parties);\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Disclosure\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Create a disclosure for a contract.\n     *\n     * Disclosures allow a party to share a contract's content with another party\n     * who isn't a stakeholder, enabling them to exercise choices that reference it.\n     *\n     * @param contractId The contract to create disclosure for\n     * @param parties Parties that have visibility to the contract\n     * @returns The disclosed contract, or undefined if contract not found\n     *\n     * @example\n     * ```ts\n     * // Alice creates disclosure for Bob to use\n     * const disclosure = await aliceSdk.createDisclosure(contractId, [aliceParty]);\n     * if (disclosure) {\n     *     // Bob uses the disclosure in his submission\n     *     await bobSdk.submit(\n     *         { actAs: [bobParty] },\n     *         [command],\n     *         { disclosedContracts: [disclosure] }\n     *     );\n     * }\n     * ```\n     */\n    createDisclosure<T extends object>(\n        contractId: ContractId<T>,\n        parties: Party[],\n    ): Promise<CantonDisclosedContract | undefined> {\n        return this.#client.createDisclosure(contractId, parties);\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Utilities\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Get connected synchronizers.\n     */\n    connectedSynchronizers(): Promise<string[]> {\n        return this.#client.connectedSynchronizers();\n    }\n\n    /**\n     * Upload a DAR to the participant node.\n     *\n     * POST /v2/dars\n     *\n     * @param opts.skipIfVetted - If true, treat KNOWN_PACKAGE_VERSION errors as success\n     */\n    uploadDar(\n        dar: Uint8Array<ArrayBuffer>,\n        opts?: { vetAllPackages?: boolean; synchronizerId?: string; skipIfVetted?: boolean },\n    ): Promise<object> {\n        return this.#client.uploadDar(dar, opts);\n    }\n\n    /**\n     * Validate a DAR for upgrade compatibility against the current vetting state.\n     *\n     * POST /v2/dars/validate\n     */\n    validateDar(dar: Uint8Array<ArrayBuffer>, opts?: { synchronizerId?: string }): Promise<void> {\n        return this.#client.validateDar(dar, opts);\n    }\n\n    /**\n     * List all known parties on the participant node.\n     *\n     * GET /v2/parties\n     *\n     * @param opts.pageSize - Maximum number of results per page\n     * @param opts.pageToken - Pagination token from previous response\n     * @returns Array of party IDs\n     */\n    listParties(opts?: {\n        pageSize?: number;\n        pageToken?: string;\n    }): Promise<{ parties: string[]; nextPageToken?: string }> {\n        return this.#client.listParties(opts);\n    }\n\n    /**\n     * List the parties the configured user can act/read as.\n     *\n     * Narrower than {@link listParties} (all parties on the node): use this when a\n     * call needs the caller's own read-scoped parties.\n     */\n    listUserParties(): Promise<string[]> {\n        return this.#client.listUserParties();\n    }\n\n    /**\n     * Allocate a new party on the participant node.\n     *\n     * POST /v2/parties\n     *\n     * @param partyIdHint - A hint for the party ID (e.g., \"alice\", \"bob\")\n     * @param opts.userId - User who gets actAs rights (empty string = no user)\n     * @param opts.synchronizerId - Synchronizer to allocate on (auto-detected if omitted)\n     * @param opts.identityProviderId - Identity provider ID (empty string = default)\n     * @returns The allocated party ID\n     */\n    allocateParty(\n        partyIdHint: string,\n        opts?: { userId?: string; synchronizerId?: string; identityProviderId?: string },\n    ): Promise<string> {\n        return this.#client.allocateParty(partyIdHint, opts);\n    }\n\n    /**\n     * Get the package ID for a package by name.\n     *\n     * POST /v2/interactive-submission/preferred-packages\n     *\n     * @param packageName - The package name (e.g., \"layerzero-oft\")\n     * @param parties - Parties whose vetting state should be considered\n     * @param opts.synchronizerId - Synchronizer to query (auto-detected if omitted)\n     * @returns The package ID (hash)\n     */\n    getPackageId(\n        packageName: string,\n        parties: string[],\n        opts?: { synchronizerId?: string },\n    ): Promise<string> {\n        return this.#client.getPackageId(packageName, parties, opts);\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Active Contracts Query\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Get the current ledger end offset.\n     *\n     * GET /v2/state/ledger-end\n     *\n     * @returns The current ledger end offset\n     */\n    getLedgerEndOffset(): Promise<number> {\n        return this.#client.getLedgerEndOffset();\n    }\n\n    /**\n     * Query active contracts at a given offset with optional template filtering.\n     *\n     * POST /v2/state/active-contracts\n     *\n     * @param party - Party to query as (for visibility)\n     * @param offset - Ledger offset to query at\n     * @param opts.templateIds - Template IDs to filter by (e.g., \"packageId:Module:Template\")\n     * @param opts.limit - Maximum number of contracts to return\n     * @returns Array of active contracts\n     *\n     * @example\n     * ```ts\n     * const offset = await sdk.getLedgerEndOffset();\n     * const contracts = await sdk.queryActiveContracts(party, offset, {\n     *     templateIds: ['packageId:SimpleRequest:SimpleRequest'],\n     *     limit: 100,\n     * });\n     * for (const contract of contracts) {\n     *     console.log(contract.createdEvent.contractId, contract.createdEvent.templateId);\n     * }\n     * ```\n     */\n    queryActiveContracts(\n        party: string,\n        offset: number,\n        opts?: { templateIds?: string[]; limit?: number; includeCreatedEventBlob?: boolean },\n    ): Promise<JsActiveContract[]> {\n        return this.#client.queryActiveContracts(party, offset, opts);\n    }\n\n    /**\n     * Normalize a ledger API JsActiveContract to a flat shape (contractId, templateId, payload, synchronizerId).\n     * Useful when you only need these fields and not createdEvent / reassignmentCounter.\n     */\n    static normalizeActiveContract(contract: JsActiveContract): NormalizedActiveContract {\n        const e = contract.createdEvent;\n        return {\n            contractId: e.contractId,\n            templateId: e.templateId,\n            payload: e.createArgument,\n            synchronizerId: contract.synchronizerId,\n        };\n    }\n\n    /**\n     * Query active contracts visible to any of the given parties (single API call).\n     */\n    queryActiveContractsByParties(\n        parties: string[],\n        offset: number,\n        templateIds: string[],\n        opts?: { limit?: number },\n    ): Promise<JsActiveContract[]> {\n        return this.#client.queryActiveContractsByParties(parties, offset, templateIds, opts);\n    }\n\n    /**\n     * Query active contracts visible to any of the given parties that implement\n     * the given interfaces (single API call).\n     */\n    queryActiveContractsByInterface(\n        parties: string[],\n        offset: number,\n        interfaceIds: string[],\n        opts?: { limit?: number; includeCreatedEventBlob?: boolean },\n    ): Promise<JsActiveContract[]> {\n        return this.#client.queryActiveContractsByInterface(parties, offset, interfaceIds, opts);\n    }\n\n    /**\n     * Query active contracts visible to any of the given parties, deduplicated by contractId.\n     * Returns normalized contracts (flat shape). Use when you need a merged view across multiple parties.\n     *\n     * @param parties - Party IDs to query as (contracts visible to any party are included, each contract once)\n     * @param opts - Optional templateIds and limit (passed per-party to the ledger API); optional templateFilter (applied after fetch)\n     */\n    async queryActiveContractsForParties(\n        parties: string[],\n        opts?: {\n            templateIds?: string[];\n            limit?: number;\n            /** If provided, only contracts whose templateId passes this predicate are returned. */\n            templateFilter?: (templateId: string) => boolean;\n        },\n    ): Promise<NormalizedActiveContract[]> {\n        const offset = await this.#client.getLedgerEndOffset();\n        const { templateFilter, ...apiOpts } = opts ?? {};\n        const perPartyResults = await Promise.all(\n            parties.map((partyId) => this.#client.queryActiveContracts(partyId, offset, apiOpts)),\n        );\n        const seen = new Set<string>();\n        const result: NormalizedActiveContract[] = [];\n        for (const contracts of perPartyResults) {\n            for (const c of contracts) {\n                const cid = c.createdEvent.contractId;\n                if (!seen.has(cid)) {\n                    seen.add(cid);\n                    const normalized = CantonSdk.normalizeActiveContract(c);\n                    if (!templateFilter || templateFilter(normalized.templateId)) {\n                        result.push(normalized);\n                    }\n                }\n            }\n        }\n        return result;\n    }\n}\n"]}

package/dist/7JEW4NHI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/refresh/callback-lock-unlock.ts"],"names":["HOLDING_INTERFACE","resolveLockUnlockCallbackContext","sdk","informee","appUid","treasury","instrumentId","offset","receivers","environment","holdings","fetchCallbackHoldings","treasuryAssetCids","map","holding","createdEvent","contractId","treasuryDisclosures","callbackDisclosure","length","disclosedContracts","urls","discoveryUrlsForAppUid","Error","firstHoldingAmount","callbackInterfaceView","amount","find","factoryId","choiceContext","fetchMergedTransferFactoryContext","inputHoldingCids","sender","credentialDisclosures","discloseUtilityCredentials","values","transferFactoryCid","assetTransferContext"],"mappings":";;;;;AAWA,IAAMA,iBAAAA,GAAoB,iEAAA;AAEnB,IAAMC,gCAAAA,mBAAmC,MAAA,CAAA,OAAO,EACnDC,GAAAA,EACAC,QAAAA,EACAC,MAAAA,EACAC,QAAAA,EACAC,YAAAA,EACAC,MAAAA,EACAC,SAAAA,EACAC,WAAAA,EAAW,KAUd;AAMG,EAAA,MAAMC,WAAW,MAAMC,qBAAAA,CAAsBT,GAAAA,EAAKG,QAAAA,EAAUE,QAAQD,YAAAA,CAAAA;AACpE,EAAA,MAAMM,oBAAoBF,QAAAA,CAASG,GAAAA,CAAI,CAACC,OAAAA,KAAYA,OAAAA,CAAQC,aAAaC,UAAU,CAAA;AACnF,EAAA,MAAMC,mBAAAA,GAAsBP,QAAAA,CAASG,GAAAA,CAAIK,kBAAAA,CAAAA;AACzC,EAAA,IAAIV,SAAAA,CAAUW,MAAAA,KAAW,CAAA,EACrB,OAAO;IAAEC,kBAAAA,EAAoBH,mBAAAA;AAAqBL,IAAAA;AAAkB,GAAA;AAExE,EAAA,MAAMS,OAAO,MAAMC,sBAAAA,CAAuBpB,GAAAA,EAAKC,QAAAA,EAAUI,QAAQH,MAAAA,CAAAA;AACjE,EAAA,IAAIiB,IAAAA,CAAKF,MAAAA,KAAW,CAAA,EAChB,MAAM,IAAII,KAAAA,CACN,CAAA,8CAAA,EAAiDnB,MAAAA,CAAAA,QAAAA,EAAiBiB,IAAAA,CAAKF,MAAM,CAAA,CAAE,CAAA;AAEvF,EAAA,MAAMK,qBAAqBd,QAAAA,CACtBG,GAAAA,CAAI,CAACC,OAAAA,KAAYW,sBAAsBX,OAAAA,EAASd,iBAAAA,CAAAA,EAAoB0B,MAAAA,EACpEC,IAAAA,CAAK,CAACD,WAA6BA,MAAAA,IAAU,IAAA,IAAQA,WAAW,GAAA,CAAA;AACrE,EAAA,MAAM,EAAEE,SAAAA,EAAWC,aAAAA,EAAeT,kBAAAA,EAAkB,GAChD,MAAMU,iCAAAA,CAAkCT,IAAAA,CAAK,CAAA,CAAA,EAAKf,YAAAA,EAAc;AAC5DG,IAAAA,WAAAA;IACAsB,gBAAAA,EAAkBnB,iBAAAA;IAClBoB,MAAAA,EAAQ3B,QAAAA;AACRqB,IAAAA,MAAAA,EAAQF,kBAAAA,IAAsB,GAAA;AAC9BhB,IAAAA;GACJ,CAAA;AACJ,EAAA,MAAMyB,qBAAAA,GAAwB,MAAMC,0BAAAA,CAChChC,GAAAA,EACA2B,cAAcM,MAAAA,CAAO,6CAAA,CAAA,EACrB9B,QAAAA,EACA,QAAA,CAAA;AAEJ,EAAA,OAAO;IACHe,kBAAAA,EAAoB;AACbH,MAAAA,GAAAA,mBAAAA;AACAG,MAAAA,GAAAA,kBAAAA;AACAa,MAAAA,GAAAA;;AAEPrB,IAAAA,iBAAAA;IACAwB,kBAAAA,EAAoBR,SAAAA;AACpBS,IAAAA,oBAAAA,EAAsBR,aAAAA,CAAcM;AACxC,GAAA;AACJ,CAAA,EA9DgD,kCAAA","file":"7JEW4NHI.js","sourcesContent":["import type { InstrumentId } from '../client/amulet';\nimport type { CantonSdk } from '../sdk';\nimport type { CantonDisclosedContract } from '../transaction';\nimport { callbackDisclosure, callbackInterfaceView } from './callback-contracts';\nimport {\n    discloseUtilityCredentials,\n    discoveryUrlsForAppUid,\n    fetchCallbackHoldings,\n    fetchMergedTransferFactoryContext,\n} from './registry-context';\n\nconst HOLDING_INTERFACE = '#splice-api-token-holding-v1:Splice.Api.Token.HoldingV1:Holding';\n\nexport const resolveLockUnlockCallbackContext = async ({\n    sdk,\n    informee,\n    appUid,\n    treasury,\n    instrumentId,\n    offset,\n    receivers,\n    environment,\n}: {\n    sdk: CantonSdk;\n    informee: string;\n    appUid: string;\n    treasury: string;\n    instrumentId: InstrumentId;\n    offset: number;\n    receivers: string[];\n    environment?: string;\n}): Promise<{\n    disclosedContracts: CantonDisclosedContract[];\n    treasuryAssetCids: string[];\n    transferFactoryCid?: string;\n    assetTransferContext?: Record<string, unknown>;\n}> => {\n    const holdings = await fetchCallbackHoldings(sdk, treasury, offset, instrumentId);\n    const treasuryAssetCids = holdings.map((holding) => holding.createdEvent.contractId);\n    const treasuryDisclosures = holdings.map(callbackDisclosure);\n    if (receivers.length === 0)\n        return { disclosedContracts: treasuryDisclosures, treasuryAssetCids };\n\n    const urls = await discoveryUrlsForAppUid(sdk, informee, offset, appUid);\n    if (urls.length !== 1)\n        throw new Error(\n            `Expected exactly one discovery URL for appUid ${appUid}, found ${urls.length}`,\n        );\n    const firstHoldingAmount = holdings\n        .map((holding) => callbackInterfaceView(holding, HOLDING_INTERFACE)?.amount)\n        .find((amount): amount is string => amount != null && amount !== '0');\n    const { factoryId, choiceContext, disclosedContracts } =\n        await fetchMergedTransferFactoryContext(urls[0]!, instrumentId, {\n            environment,\n            inputHoldingCids: treasuryAssetCids,\n            sender: treasury,\n            amount: firstHoldingAmount ?? '0',\n            receivers,\n        });\n    const credentialDisclosures = await discloseUtilityCredentials(\n        sdk,\n        choiceContext.values['utility.digitalasset.com/sender-credentials'],\n        treasury,\n        'sender',\n    );\n    return {\n        disclosedContracts: [\n            ...treasuryDisclosures,\n            ...disclosedContracts,\n            ...credentialDisclosures,\n        ],\n        treasuryAssetCids,\n        transferFactoryCid: factoryId,\n        assetTransferContext: choiceContext.values,\n    };\n};\n"]}

package/dist/CNSI6MLV.js

@@ -1,3 +0,0 @@
-
-//# sourceMappingURL=CNSI6MLV.js.map
-//# sourceMappingURL=CNSI6MLV.js.map

package/dist/CNSI6MLV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"CNSI6MLV.js"}

package/dist/KFTXC6M6.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/client/canton-client.ts"],"names":["CantonClient","config","userId","wallet","DefaultApi","CantonProtocolError","getDsoParty","walletUrl","tokenProvider","fetchDsoParty","getToken","getAmuletTransferFactoryContext","args","fetchAmuletTransferFactoryContext","getTransferInstructionContext","fetchTransferInstructionContext","token","getTransferInstructionAcceptContext","contractId","fetchAcceptContext","getAmuletContextWithExternalRules","instrumentId","amuletContext","disclosedContracts","fetchAmuletContext","contextWithRules","externalPartyAmuletRulesCid","injectExternalPartyAmuletRules","obj","key","undefined","pascal","charAt","toUpperCase","slice","camel","toLowerCase","call","err","ResponseError","cantonApiErrorFromResponse","response","parties","includeCreatedEventBlob","Object","fromEntries","map","p","cumulative","identifierFilter","wildcardFilter","value","event","templateId","createdEventBlob","preparedTransaction","preparedTransactionHash","hashingSchemeVersion","connectedSynchronizers","getV2StateConnectedSynchronizers","synchronizerId","once","id","CantonTransportError","uploadDar","dar","opts","bytes","byteOffset","byteLength","buffer","body","Blob","type","request","vetAllPackages","postV2Dars","skipIfVetted","CantonApiError","code","skipped","reason","details","validateDar","then","postV2DarsValidate","listParties","getV2Parties","pageSize","pageToken","partyDetails","party","nextPageToken","listUserRights","apiResponse","getV2UsersUserIdRightsRaw","raw","json","rights","listUserParties","Set","right","kind","CanActAs","CanReadAs","add","allocateParty","partyIdHint","postV2Parties","allocatePartyRequest","identityProviderId","generateExternalPartyTopology","generateExternalPartyTopologyRequest","synchronizer","partyHint","publicKey","localParticipantObservationOnly","confirmationThreshold","postV2PartiesExternalGenerateTopology","partyId","multiHash","topologyTransactions","length","allocateExternalParty","allocateExternalPartyRequest","onboardingTransactions","tx","transaction","multiHashSignatures","postV2PartiesExternalAllocate","grantCanActAs","postV2UsersUserIdRights","grantUserRightsRequest","canActAs","getPackageId","packageName","getPreferredPackagesRequest","packageVettingRequirements","postV2InteractiveSubmissionPreferredPackages","packageRef","packageReferences","find","ref","packageId","submit","actors","commands","commandId","randomUUID","completionOffset","getLedgerEndOffset","jsCommands","actAs","readAs","postV2CommandsAsyncSubmit","waitForCommand","timeoutMs","poll","limit","streamIdleTimeoutMs","initialBackoffMs","backoffMs","initial","maxBackoffMs","max","beginExclusive","currentBackoff","deadline","Date","now","completionStreamRequest","rawResponse","postV2CommandsCompletionsRaw","responseText","text","completions","JSON","parse","item","normalized","completionResponse","offsetCheckpoint","checkpoint","checkpointOffset","Math","completionWrapper","completion","offset","completionCommandId","status","updateId","error","message","remainingTime","sleepTime","min","Promise","resolve","setTimeout","lastCheckedOffset","interfaceIds","getEventsByContractIdRequest","eventFormat","filtersByParty","verbose","postV2EventsEventsByContractId","archived","created","createdEvent","createDisclosure","validated","fetchContractById","fetchEventsByContractId","archivedEvent","fetchTransactionByUpdateId","postV2UpdatesUpdateByIdRaw","getUpdateByIdRequest","updateFormat","updateResponse","fetchTransactionByOffset","postV2UpdatesUpdateByOffsetRaw","getUpdateByOffsetRequest","prepareForSigning","jsPrepareSubmissionRequest","verboseHashing","packageIdSelectionPreference","postV2InteractiveSubmissionPrepare","submitSigned","prepared","signatures","jsExecuteSubmissionRequest","partySignatures","sig","format","signature","signedBy","signingAlgorithmSpec","deduplicationPeriod","deduplicationDuration","seconds","nanos","submissionId","postV2InteractiveSubmissionExecute","getV2StateLedgerEnd","queryActiveContracts","queryActiveContractsByParties","templateIds","queryActiveContractsByInterface","cumulativeFilter","postV2StateActiveContractsRaw","getActiveContractsRequest","activeAtOffset","rawJson","contractEntry","JsActiveContract","filter","contract","JsActiveContractFromJSON","getUpdates","endInclusive","postV2UpdatesRaw","getUpdatesRequest","includeTransactions","transactionShape","updateResponses","update","templateFilter","interfaceId","interfaceFilter","includeInterfaceView","notFoundMessage","Transaction"],"mappings":"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","file":"KFTXC6M6.js","sourcesContent":["import type { ContractId } from '@daml/types';\nimport { once } from 'es-toolkit';\nimport { randomUUID } from 'node:crypto';\n\nimport {\n    CantonApiError,\n    cantonApiErrorFromResponse,\n    CantonProtocolError,\n    CantonTransportError,\n} from '../errors';\nimport {\n    DefaultApi,\n    type PostV2CommandsAsyncSubmitRequest,\n    type PostV2CommandsCompletionsRequest,\n    type PostV2DarsRequest,\n    type PostV2DarsValidateRequest,\n    type PostV2EventsEventsByContractIdRequest,\n    type PostV2InteractiveSubmissionExecuteRequest,\n    type PostV2InteractiveSubmissionPreferredPackagesRequest,\n    type PostV2InteractiveSubmissionPrepareRequest,\n    type PostV2PartiesExternalAllocateRequest,\n    type PostV2PartiesExternalGenerateTopologyRequest,\n} from '../open-api/apis/DefaultApi';\nimport {\n    type ArchivedEvent,\n    type Command,\n    type CreatedEvent,\n    type CumulativeFilter,\n    type DisclosedContract,\n    type JsActiveContract,\n    JsActiveContractFromJSON,\n} from '../open-api/models';\nimport { type Configuration, ResponseError } from '../open-api/runtime';\nimport type { CantonDisclosedContract } from '../transaction';\nimport type {\n    ExternalSignature,\n    PreparedTransaction,\n    SubmitActors,\n    SubmitResult,\n    UserRight,\n    WaitOptions,\n    WaitResult,\n} from '../types';\nimport {\n    type AmuletContextResult,\n    type AmuletTransferFactoryArgs,\n    type CantonClientWalletConfig,\n    fetchAcceptContext,\n    fetchAmuletContext,\n    fetchAmuletTransferFactoryContext,\n    fetchDsoParty,\n    fetchTransferInstructionContext,\n    injectExternalPartyAmuletRules,\n    type InstrumentId,\n    type TransferInstructionAcceptContextResult,\n    type TransferInstructionChoice,\n} from './amulet';\nimport type {\n    CantonTransaction,\n    CantonUpdate,\n    CantonUpdateResponse,\n    ICantonClient,\n} from './interface';\n\n/**\n * CantonClient - The engine layer for Canton ledger operations.\n *\n * Responsibilities:\n * - Synchronizer discovery and caching\n * - Command submission and completion waiting\n * - Disclosed contract building\n * - JSON normalization (temporary workaround)\n *\n * This class uses composition (not inheritance) to wrap the generated API,\n * exposing only the minimal surface needed for ledger app operations.\n */\nexport class CantonClient implements ICantonClient {\n    readonly #api: DefaultApi;\n    readonly #userId: string;\n    readonly #wallet?: CantonClientWalletConfig;\n    #dsoParty?: string;\n\n    constructor(\n        config: Configuration,\n        userId: string = 'participant_admin',\n        wallet?: CantonClientWalletConfig,\n    ) {\n        this.#api = new DefaultApi(config);\n        this.#userId = userId;\n        this.#wallet = wallet;\n    }\n\n    #requireWallet(): CantonClientWalletConfig {\n        if (!this.#wallet) {\n            throw new CantonProtocolError(\n                'CantonClient has no wallet config (walletUrl + tokenProvider); amulet endpoints are unavailable',\n            );\n        }\n        return this.#wallet;\n    }\n\n    async getDsoParty(): Promise<string> {\n        const { walletUrl, tokenProvider } = this.#requireWallet();\n        if (this.#dsoParty) return this.#dsoParty;\n        this.#dsoParty = await fetchDsoParty(walletUrl, await tokenProvider.getToken());\n        return this.#dsoParty;\n    }\n\n    async getAmuletTransferFactoryContext(args: AmuletTransferFactoryArgs) {\n        const { walletUrl, tokenProvider } = this.#requireWallet();\n        return fetchAmuletTransferFactoryContext(walletUrl, await tokenProvider.getToken(), args);\n    }\n\n    async getTransferInstructionContext(args: {\n        contractId: string;\n        choice: TransferInstructionChoice;\n    }): Promise<TransferInstructionAcceptContextResult> {\n        const { walletUrl, tokenProvider } = this.#requireWallet();\n        return fetchTransferInstructionContext({\n            ...args,\n            walletUrl,\n            token: await tokenProvider.getToken(),\n        });\n    }\n\n    async getTransferInstructionAcceptContext({\n        contractId,\n    }: {\n        contractId: string;\n    }): Promise<TransferInstructionAcceptContextResult> {\n        const { walletUrl, tokenProvider } = this.#requireWallet();\n        return fetchAcceptContext({ walletUrl, token: await tokenProvider.getToken(), contractId });\n    }\n\n    /** Amulet ChoiceContext with ExternalPartyAmuletRules injected — required by every flow hitting FeeUtils.validateContext. */\n    async getAmuletContextWithExternalRules(\n        instrumentId: InstrumentId,\n    ): Promise<AmuletContextResult> {\n        const { walletUrl, tokenProvider } = this.#requireWallet();\n        const { amuletContext, disclosedContracts } = await fetchAmuletContext(\n            walletUrl,\n            await tokenProvider.getToken(),\n            instrumentId,\n        );\n        const { amuletContext: contextWithRules, externalPartyAmuletRulesCid } =\n            injectExternalPartyAmuletRules(amuletContext, disclosedContracts);\n        return { amuletContext: contextWithRules, disclosedContracts, externalPartyAmuletRulesCid };\n    }\n\n    /**\n     * Get a property from an object, trying PascalCase first then camelCase.\n     * Canton API returns PascalCase but OpenAPI expects camelCase.\n     */\n    #getField<T>(obj: Record<string, unknown> | undefined, key: string): T | undefined {\n        if (!obj) return undefined;\n        const pascal = key.charAt(0).toUpperCase() + key.slice(1);\n        const camel = key.charAt(0).toLowerCase() + key.slice(1);\n        return (obj[pascal] ?? obj[camel]) as T | undefined;\n    }\n\n    /**\n     * Run an API call, normalizing a thrown `ResponseError` into a `CantonApiError`\n     * that carries `errorCategory` (for retry classification). Other errors pass through.\n     */\n    async #invoke<T>(call: () => Promise<T>): Promise<T> {\n        try {\n            return await call();\n        } catch (err) {\n            if (err instanceof ResponseError) {\n                throw await cantonApiErrorFromResponse(err.response);\n            }\n            throw err;\n        }\n    }\n\n    /**\n     * Build party-based filter object for event queries.\n     */\n    #buildPartyFilters(parties: string[], includeCreatedEventBlob: boolean) {\n        return Object.fromEntries(\n            parties.map((p) => [\n                p,\n                {\n                    cumulative: [\n                        {\n                            identifierFilter: {\n                                wildcardFilter: { value: { includeCreatedEventBlob } },\n                            },\n                        },\n                    ],\n                },\n            ]),\n        );\n    }\n\n    /**\n     * Validate and extract disclosure fields from a CreatedEvent.\n     */\n    #validateDisclosureEvent(\n        event: { templateId?: string; contractId?: string; createdEventBlob?: string },\n        contractId: ContractId<unknown>,\n    ): { templateId: string; contractId: string; createdEventBlob: string } {\n        if (!event.templateId) {\n            throw new CantonProtocolError('Disclosure response missing templateId', {\n                contractId,\n            });\n        }\n        if (!event.contractId) {\n            throw new CantonProtocolError('Disclosure response missing contractId', {\n                contractId,\n            });\n        }\n        if (!event.createdEventBlob) {\n            throw new CantonProtocolError('Disclosure response missing createdEventBlob', {\n                contractId,\n            });\n        }\n        return {\n            templateId: event.templateId,\n            contractId: event.contractId,\n            createdEventBlob: event.createdEventBlob,\n        };\n    }\n\n    /**\n     * Validate and extract prepared transaction fields from a prepare response.\n     */\n    #validatePrepareResponse(response: {\n        preparedTransaction?: string;\n        preparedTransactionHash?: string;\n        hashingSchemeVersion?: string;\n    }): {\n        preparedTransaction: string;\n        preparedTransactionHash: string;\n        hashingSchemeVersion: string;\n    } {\n        if (!response.preparedTransaction) {\n            throw new CantonProtocolError('Prepare response missing preparedTransaction');\n        }\n        if (!response.preparedTransactionHash) {\n            throw new CantonProtocolError('Prepare response missing preparedTransactionHash');\n        }\n        if (!response.hashingSchemeVersion) {\n            throw new CantonProtocolError('Prepare response missing hashingSchemeVersion');\n        }\n        return {\n            preparedTransaction: response.preparedTransaction,\n            preparedTransactionHash: response.preparedTransactionHash,\n            hashingSchemeVersion: response.hashingSchemeVersion,\n        };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Synchronizer Discovery\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Returns all connected synchronizer IDs.\n     */\n    async connectedSynchronizers(): Promise<string[]> {\n        const response = await this.#invoke(() => this.#api.getV2StateConnectedSynchronizers());\n\n        return response.connectedSynchronizers?.map(({ synchronizerId }) => synchronizerId) ?? [];\n    }\n\n    /**\n     * Internal: ensures we have a cached synchronizer ID, fetching if needed.\n     */\n    #ensureSynchronizerId = once(async (): Promise<string> => {\n        const [id] = await this.connectedSynchronizers();\n\n        if (!id) {\n            throw new CantonTransportError('No connected synchronizers found');\n        }\n\n        return id;\n    });\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // DAR Upload / Validation\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Upload a DAR (Daml Archive) to the participant node.\n     *\n     * @param dar - Raw DAR bytes.\n     * @param opts.vetAllPackages - Whether to vet all packages in the DAR.\n     * @param opts.synchronizerId - Synchronizer to upload to (auto-detected if omitted).\n     * @param opts.skipIfVetted - If true, silently succeeds when the DAR is already vetted.\n     */\n    async uploadDar(\n        dar: Uint8Array<ArrayBuffer>,\n        opts: { vetAllPackages?: boolean; synchronizerId?: string; skipIfVetted?: boolean } = {},\n    ): Promise<object> {\n        // Extract the underlying ArrayBuffer, handling views that don't start at offset 0\n        const bytes =\n            dar.byteOffset === 0 && dar.byteLength === dar.buffer.byteLength\n                ? dar.buffer\n                : dar.buffer.slice(dar.byteOffset, dar.byteOffset + dar.byteLength);\n        const body = new Blob([bytes], { type: 'application/octet-stream' });\n        const synchronizerId = opts.synchronizerId ?? (await this.#ensureSynchronizerId());\n        const request: PostV2DarsRequest = {\n            body,\n            vetAllPackages: opts.vetAllPackages,\n            synchronizerId,\n        };\n\n        try {\n            return await this.#invoke(() => this.#api.postV2Dars(request));\n        } catch (err: unknown) {\n            // If skipIfVetted, treat KNOWN_PACKAGE_VERSION as a no-op success\n            if (\n                opts.skipIfVetted &&\n                err instanceof CantonApiError &&\n                err.code === 'KNOWN_PACKAGE_VERSION'\n            ) {\n                return { skipped: true, reason: 'already_vetted', details: err.body };\n            }\n            throw err;\n        }\n    }\n\n    /**\n     * Validate a DAR against the participant without uploading it.\n     *\n     * @param dar - Raw DAR bytes.\n     * @param opts.synchronizerId - Synchronizer to validate against (auto-detected if omitted).\n     */\n    async validateDar(\n        dar: Uint8Array<ArrayBuffer>,\n        opts: { synchronizerId?: string } = {},\n    ): Promise<void> {\n        const bytes =\n            dar.byteOffset === 0 && dar.byteLength === dar.buffer.byteLength\n                ? dar.buffer\n                : dar.buffer.slice(dar.byteOffset, dar.byteOffset + dar.byteLength);\n        const body = new Blob([bytes], { type: 'application/octet-stream' });\n        const request: PostV2DarsValidateRequest = {\n            body,\n            synchronizerId: opts.synchronizerId,\n        };\n\n        if (!request.synchronizerId) {\n            return this.#ensureSynchronizerId().then((synchronizerId) =>\n                this.#invoke(() => this.#api.postV2DarsValidate({ ...request, synchronizerId })),\n            );\n        }\n\n        return this.#invoke(() => this.#api.postV2DarsValidate(request));\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Party Management\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * List all known parties on the participant node.\n     *\n     * @param opts.pageSize - Maximum number of results per page\n     * @param opts.pageToken - Pagination token from previous response\n     * @returns Array of party IDs and pagination token\n     */\n    async listParties(\n        opts: { pageSize?: number; pageToken?: string } = {},\n    ): Promise<{ parties: string[]; nextPageToken?: string }> {\n        const response = await this.#invoke(() =>\n            this.#api.getV2Parties({\n                pageSize: opts.pageSize,\n                pageToken: opts.pageToken,\n            }),\n        );\n\n        return {\n            parties: response.partyDetails?.map((p) => p.party) ?? [],\n            nextPageToken: response.nextPageToken,\n        };\n    }\n\n    /**\n     * Return the rights granted to the current user (this.#userId).\n     *\n     * Bypasses the OpenAPI generator's typed `Kind` converter, which is\n     * broken: `instanceOfKindOneOf` checks lowercase `canActAs in value`, but\n     * `KindOneOfFromJSONTyped` reads uppercase `json['CanActAs']`, so the\n     * typed client returns every `kind` as `{}`. We parse the raw JSON\n     * ourselves to preserve the actual variant payload.\n     */\n    async listUserRights(): Promise<UserRight[]> {\n        const apiResponse = await this.#invoke(() =>\n            this.#api.getV2UsersUserIdRightsRaw({\n                userId: this.#userId,\n            }),\n        );\n        const raw = (await apiResponse.raw.json()) as { rights?: UserRight[] };\n        return raw.rights ?? [];\n    }\n\n    /**\n     * Return the parties the current user has CanActAs or CanReadAs rights\n     * for. Convenience wrapper over `listUserRights()` for the common case\n     * where the caller just needs party-scoped access (e.g. to query events\n     * or fetch transactions).\n     *\n     * Use this instead of `listParties()` when the caller only has scoped\n     * rights — `listParties()` returns *all* parties on the participant\n     * (including DSO, splice parties), and Canton returns 403 if you query\n     * as a party you can't read.\n     */\n    async listUserParties(): Promise<string[]> {\n        const rights = await this.listUserRights();\n        const parties = new Set<string>();\n        for (const right of rights) {\n            // Only `CanActAs` / `CanReadAs` carry a party; the other four\n            // variants (ParticipantAdmin, IdentityProviderAdmin,\n            // CanReadAsAnyParty, CanExecuteAsAnyParty) have empty payloads.\n            const party = right.kind.CanActAs?.value.party ?? right.kind.CanReadAs?.value.party;\n            if (party !== undefined) {\n                parties.add(party);\n            }\n        }\n        return [...parties];\n    }\n\n    /**\n     * Allocate a new party on the participant node.\n     *\n     * @param partyIdHint - A hint for the party ID (e.g., \"alice\", \"bob\")\n     * @param opts.userId - User who gets actAs rights (empty string = no user)\n     * @param opts.synchronizerId - Synchronizer to allocate on (auto-detected if omitted)\n     * @param opts.identityProviderId - Identity provider ID (empty string = default)\n     * @returns The allocated party ID\n     */\n    async allocateParty(\n        partyIdHint: string,\n        opts: { userId?: string; synchronizerId?: string; identityProviderId?: string } = {},\n    ): Promise<string> {\n        const synchronizerId = opts.synchronizerId ?? (await this.#ensureSynchronizerId());\n\n        const response = await this.#invoke(() =>\n            this.#api.postV2Parties({\n                allocatePartyRequest: {\n                    partyIdHint,\n                    synchronizerId,\n                    userId: opts.userId ?? '',\n                    identityProviderId: opts.identityProviderId ?? '',\n                },\n            }),\n        );\n\n        const party = response.partyDetails?.party;\n        if (!party) {\n            throw new CantonProtocolError('Party allocation response missing party ID');\n        }\n\n        return party;\n    }\n\n    /**\n     * Generate unsigned topology transactions for an external party.\n     *\n     * POST /v2/parties/external/generate-topology\n     */\n    async generateExternalPartyTopology(args: {\n        partyHint: string;\n        publicKey: { format: string; keyData: string; keySpec: string };\n        localParticipantObservationOnly: boolean;\n        confirmationThreshold: number;\n    }): Promise<{\n        partyId: string;\n        topologyTransactions: string[];\n        multiHash: string;\n        synchronizerId: string;\n    }> {\n        const synchronizerId = await this.#ensureSynchronizerId();\n        const request: PostV2PartiesExternalGenerateTopologyRequest = {\n            generateExternalPartyTopologyRequest: {\n                synchronizer: synchronizerId,\n                partyHint: args.partyHint,\n                publicKey: args.publicKey,\n                localParticipantObservationOnly: args.localParticipantObservationOnly,\n                confirmationThreshold: args.confirmationThreshold,\n            },\n        };\n\n        const response = await this.#invoke(() =>\n            this.#api.postV2PartiesExternalGenerateTopology(request),\n        );\n\n        if (!response.partyId || !response.multiHash) {\n            throw new CantonProtocolError(\n                'generateExternalPartyTopology response missing partyId or multiHash',\n            );\n        }\n\n        if (!response.topologyTransactions?.length) {\n            throw new CantonProtocolError(\n                'generateExternalPartyTopology response missing topologyTransactions',\n            );\n        }\n\n        return {\n            partyId: response.partyId,\n            topologyTransactions: response.topologyTransactions,\n            multiHash: response.multiHash,\n            synchronizerId,\n        };\n    }\n\n    /**\n     * Submit signed topology transactions to register an external party.\n     *\n     * POST /v2/parties/external/allocate\n     */\n    async allocateExternalParty(args: {\n        synchronizerId: string;\n        topologyTransactions: string[];\n        multiHashSignatures: Array<{\n            format: string;\n            signature: string;\n            signedBy: string;\n            signingAlgorithmSpec: string;\n        }>;\n    }): Promise<string> {\n        const request: PostV2PartiesExternalAllocateRequest = {\n            allocateExternalPartyRequest: {\n                synchronizer: args.synchronizerId,\n                onboardingTransactions: args.topologyTransactions.map((tx) => ({\n                    transaction: tx,\n                })),\n                multiHashSignatures: args.multiHashSignatures,\n                identityProviderId: '',\n            },\n        };\n\n        const response = await this.#invoke(() => this.#api.postV2PartiesExternalAllocate(request));\n\n        if (!response.partyId) {\n            throw new CantonProtocolError('allocateExternalParty response missing partyId');\n        }\n\n        return response.partyId;\n    }\n\n    /**\n     * Grant canActAs right for a party to the current service user.\n     * Idempotent — safe to call even if the right is already granted.\n     *\n     * POST /v2/users/{userId}/rights\n     */\n    async grantCanActAs(partyId: string): Promise<void> {\n        await this.#invoke(() =>\n            this.#api.postV2UsersUserIdRights({\n                userId: this.#userId,\n                grantUserRightsRequest: {\n                    userId: this.#userId,\n                    rights: [{ kind: { canActAs: { value: { party: partyId } } } }],\n                    identityProviderId: '',\n                },\n            }),\n        );\n    }\n\n    /**\n     * Get the package ID for a package by name.\n     *\n     * @param packageName - The package name (e.g., \"layerzero-oft\")\n     * @param parties - Parties whose vetting state should be considered\n     * @param opts.synchronizerId - Synchronizer to query (auto-detected if omitted)\n     * @returns The package ID (hash)\n     */\n    async getPackageId(\n        packageName: string,\n        parties: string[],\n        opts: { synchronizerId?: string } = {},\n    ): Promise<string> {\n        const synchronizerId = opts.synchronizerId ?? (await this.#ensureSynchronizerId());\n\n        const request: PostV2InteractiveSubmissionPreferredPackagesRequest = {\n            getPreferredPackagesRequest: {\n                packageVettingRequirements: [\n                    {\n                        packageName,\n                        parties,\n                    },\n                ],\n                synchronizerId,\n            },\n        };\n\n        const response = await this.#invoke(() =>\n            this.#api.postV2InteractiveSubmissionPreferredPackages(request),\n        );\n\n        const packageRef = response.packageReferences?.find(\n            (ref) => ref.packageName === packageName,\n        );\n        if (!packageRef?.packageId) {\n            throw new CantonProtocolError(\n                `Package \"${packageName}\" not found or not vetted for parties`,\n            );\n        }\n\n        return packageRef.packageId;\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Command Submission\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Submit a batch of commands atomically.\n     *\n     * @returns commandId and completionOffset for use with waitForCommand()\n     */\n    async submit(\n        actors: SubmitActors,\n        commands: Command[],\n        opts: { disclosedContracts?: DisclosedContract[]; commandId?: string } = {},\n    ): Promise<SubmitResult> {\n        const synchronizerId = await this.#ensureSynchronizerId();\n        const commandId = opts.commandId ?? randomUUID();\n\n        // Snapshot ledger end before submission so waitForCommand knows where to start polling\n        const completionOffset = await this.getLedgerEndOffset();\n\n        const request: PostV2CommandsAsyncSubmitRequest = {\n            jsCommands: {\n                commandId,\n                actAs: actors.actAs,\n                readAs: actors.readAs ?? actors.actAs,\n                userId: this.#userId,\n                synchronizerId,\n                commands,\n                disclosedContracts: opts.disclosedContracts,\n            },\n        };\n\n        await this.#invoke(() => this.#api.postV2CommandsAsyncSubmit(request));\n\n        return { commandId, completionOffset };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Completion Waiting / Reconciliation\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Wait for a command to be accepted or rejected.\n     *\n     * Uses bounded exponential backoff to avoid hammering the participant.\n     */\n    async waitForCommand(commandId: string, opts: WaitOptions): Promise<WaitResult> {\n        const { parties, timeoutMs = 30_000, poll = {} } = opts;\n\n        const limit = poll.limit ?? 50;\n        const streamIdleTimeoutMs = poll.streamIdleTimeoutMs ?? 1000;\n        const initialBackoffMs = poll.backoffMs?.initial ?? 100;\n        const maxBackoffMs = poll.backoffMs?.max ?? 5000;\n\n        let beginExclusive = opts.beginExclusive ?? 0;\n        let currentBackoff = initialBackoffMs;\n        const deadline = Date.now() + timeoutMs;\n\n        // Poll the completions stream until we find our commandId or timeout\n        while (Date.now() < deadline) {\n            const request: PostV2CommandsCompletionsRequest = {\n                completionStreamRequest: {\n                    beginExclusive,\n                    parties,\n                    userId: this.#userId,\n                },\n                limit,\n                streamIdleTimeoutMs,\n            };\n\n            const rawResponse = await this.#invoke(() =>\n                this.#api.postV2CommandsCompletionsRaw(request),\n            );\n            const responseText = await rawResponse.raw.text();\n            const completions = JSON.parse(responseText) as unknown[];\n\n            // Scan each completion for our commandId\n            for (const item of completions) {\n                const normalized = item as Record<string, unknown>;\n                const completionResponse = this.#getField<Record<string, unknown>>(\n                    normalized,\n                    'completionResponse',\n                );\n                if (!completionResponse) continue;\n\n                // Handle offsetCheckpoint responses (no commandId)\n                const offsetCheckpoint = this.#getField<Record<string, unknown>>(\n                    completionResponse,\n                    'offsetCheckpoint',\n                );\n                if (offsetCheckpoint) {\n                    const checkpoint =\n                        this.#getField<Record<string, unknown>>(offsetCheckpoint, 'value') ??\n                        offsetCheckpoint;\n                    const checkpointOffset = this.#getField<number>(checkpoint, 'offset');\n                    if (checkpointOffset !== undefined) {\n                        beginExclusive = Math.max(beginExclusive, checkpointOffset);\n                    }\n                    continue;\n                }\n\n                // Navigate: completionResponse.completion.value\n                const completionWrapper = this.#getField<Record<string, unknown>>(\n                    completionResponse,\n                    'completion',\n                );\n                const completion =\n                    this.#getField<Record<string, unknown>>(completionWrapper, 'value') ??\n                    completionWrapper;\n                if (!completion) continue;\n\n                const offset = this.#getField<number>(completion, 'offset');\n                const completionCommandId = this.#getField<string>(completion, 'commandId');\n\n                // Found our command — check gRPC status to determine accept/reject\n                if (completionCommandId === commandId) {\n                    const status = this.#getField<{\n                        code?: number;\n                        message?: string;\n                        details?: unknown;\n                    }>(completion, 'status');\n\n                    // code === 0 or status undefined means success (gRPC OK)\n                    if (!status || status.code === 0) {\n                        return {\n                            status: 'accepted',\n                            commandId,\n                            updateId: this.#getField<string>(completion, 'updateId') ?? '',\n                            offset: offset ?? 0,\n                        };\n                    } else {\n                        return {\n                            status: 'rejected',\n                            commandId,\n                            offset: offset ?? 0,\n                            error: {\n                                code: status.code,\n                                message: status.message ?? 'Unknown rejection',\n                                details: status.details,\n                            },\n                        };\n                    }\n                }\n\n                // Not our command — advance offset cursor past it\n                if (offset !== undefined) {\n                    beginExclusive = Math.max(beginExclusive, offset);\n                }\n            }\n\n            // Bounded exponential backoff\n            const remainingTime = deadline - Date.now();\n            const sleepTime = Math.min(currentBackoff, remainingTime, maxBackoffMs);\n            if (sleepTime > 0) {\n                await new Promise((resolve) => setTimeout(resolve, sleepTime));\n            }\n            currentBackoff = Math.min(currentBackoff * 2, maxBackoffMs);\n        }\n\n        return { status: 'timeout', commandId, lastCheckedOffset: beginExclusive };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Disclosed Contracts\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Fetch active contract's created event by ID.\n     * Returns undefined if contract doesn't exist or is archived.\n     */\n    async #fetchActiveContractEvent(\n        contractId: ContractId<unknown>,\n        parties: string[],\n        includeCreatedEventBlob: boolean,\n        interfaceIds?: string[],\n    ): Promise<CreatedEvent | undefined> {\n        const request: PostV2EventsEventsByContractIdRequest = {\n            getEventsByContractIdRequest: {\n                contractId,\n                eventFormat: {\n                    filtersByParty: interfaceIds?.length\n                        ? Object.fromEntries(\n                              parties.map((party) => [\n                                  party,\n                                  {\n                                      cumulative: this.#buildInterfaceCumulativeFilters(\n                                          interfaceIds,\n                                          includeCreatedEventBlob,\n                                      ),\n                                  },\n                              ]),\n                          )\n                        : this.#buildPartyFilters(parties, includeCreatedEventBlob),\n                    verbose: false,\n                },\n            },\n        };\n\n        const response = await this.#invoke(() =>\n            this.#api.postV2EventsEventsByContractId(request),\n        );\n\n        // If archived, contract is not active\n        if (response.archived) return undefined;\n\n        return response.created?.createdEvent;\n    }\n\n    /**\n     * Build a disclosure for a contract.\n     *\n     * @param contractId - The contract ID to create disclosure for\n     * @param parties - Parties that have visibility to the contract\n     * @returns DisclosedContract if visible, undefined if not found\n     * @throws CantonProtocolError if contract visible but blob missing (server/config mismatch)\n     */\n    async createDisclosure(\n        contractId: ContractId<unknown>,\n        parties: string[],\n    ): Promise<CantonDisclosedContract | undefined> {\n        const synchronizerId = await this.#ensureSynchronizerId();\n        const created = await this.#fetchActiveContractEvent(contractId, parties, true);\n\n        if (!created) return undefined;\n\n        const validated = this.#validateDisclosureEvent(created, contractId);\n        return {\n            ...validated,\n            synchronizerId,\n        };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Internal: Active Contract Queries (used by CantonSdk)\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Fetch a single contract by ID.\n     *\n     * @param contractId The contract ID to fetch\n     * @param parties Parties to use for filtering (required for non-admin tokens)\n     */\n    async fetchContractById(\n        contractId: ContractId<unknown>,\n        parties: string[],\n        opts?: { interfaceIds?: string[] },\n    ): Promise<CreatedEvent | undefined> {\n        return this.#fetchActiveContractEvent(contractId, parties, false, opts?.interfaceIds);\n    }\n\n    /**\n     * Fetch both the created and archived events for a contract by ID.\n     * Unlike fetchContractById, this preserves archival information.\n     */\n    async fetchEventsByContractId(\n        contractId: string,\n        parties: string[],\n    ): Promise<{ created: CreatedEvent | undefined; archived: ArchivedEvent | undefined }> {\n        const request: PostV2EventsEventsByContractIdRequest = {\n            getEventsByContractIdRequest: {\n                contractId,\n                eventFormat: {\n                    filtersByParty: this.#buildPartyFilters(parties, false),\n                    verbose: false,\n                },\n            },\n        };\n\n        const response = await this.#invoke(() =>\n            this.#api.postV2EventsEventsByContractId(request),\n        );\n\n        return {\n            created: response.created?.createdEvent,\n            archived: response.archived?.archivedEvent,\n        };\n    }\n\n    /**\n     * Fetch an update (transaction) by its ID.\n     * @param updateId The update ID from a completion\n     * @param parties Parties to use for the query filter\n     * @returns The full update response\n     */\n    async fetchTransactionByUpdateId(\n        updateId: string,\n        parties: string[],\n    ): Promise<CantonTransaction> {\n        const response = await this.#invoke(() =>\n            this.#api.postV2UpdatesUpdateByIdRaw({\n                getUpdateByIdRequest: {\n                    updateId,\n                    updateFormat: this.#buildUpdateFormat(parties),\n                },\n            }),\n        );\n\n        const updateResponse: CantonUpdateResponse = await response.raw.json();\n        return this.#parseTransactionFromUpdate(\n            updateResponse,\n            `Update ${updateId} is not a transaction`,\n        );\n    }\n\n    /**\n     * Fetch a transaction by its offset.\n     * @param offset - The ledger offset\n     * @param parties - Parties to use for the query filter\n     * @returns The full transaction including recordTime\n     */\n    async fetchTransactionByOffset(offset: number, parties: string[]): Promise<CantonTransaction> {\n        const response = await this.#invoke(() =>\n            this.#api.postV2UpdatesUpdateByOffsetRaw({\n                getUpdateByOffsetRequest: {\n                    offset,\n                    updateFormat: this.#buildUpdateFormat(parties),\n                },\n            }),\n        );\n\n        const updateResponse: CantonUpdateResponse = await response.raw.json();\n        return this.#parseTransactionFromUpdate(\n            updateResponse,\n            `Update at offset ${offset} is not a transaction`,\n        );\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // External Party / Interactive Submission\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Prepare commands for external party signing.\n     *\n     * Returns a typed PreparedTransaction that preserves the contract type\n     * through the signing flow. After signing, use submitSigned() to submit.\n     *\n     * @typeparam T The contract payload type (phantom type for type safety)\n     *\n     * @example\n     * ```ts\n     * const prepared = await client.prepareForSigning<Oft>({ actAs: [party] }, [cmd]);\n     * const signature = await sign(prepared.preparedTransactionHash);\n     * await client.submitSigned(prepared, [signature]);\n     * ```\n     */\n    async prepareForSigning(\n        actors: SubmitActors,\n        commands: Command[],\n        opts: { disclosedContracts?: DisclosedContract[]; commandId?: string } = {},\n    ): Promise<PreparedTransaction> {\n        const synchronizerId = await this.#ensureSynchronizerId();\n        const commandId = opts.commandId ?? randomUUID();\n\n        const request: PostV2InteractiveSubmissionPrepareRequest = {\n            jsPrepareSubmissionRequest: {\n                userId: this.#userId,\n                commandId,\n                commands,\n                actAs: actors.actAs,\n                readAs: actors.readAs ?? actors.actAs,\n                disclosedContracts: opts.disclosedContracts,\n                synchronizerId,\n                verboseHashing: false,\n                packageIdSelectionPreference: [],\n            },\n        };\n\n        const response = await this.#invoke(() =>\n            this.#api.postV2InteractiveSubmissionPrepare(request),\n        );\n        const validated = this.#validatePrepareResponse(response);\n\n        return {\n            ...validated,\n            hashingSchemeVersion:\n                validated.hashingSchemeVersion as PreparedTransaction['hashingSchemeVersion'],\n            commandId,\n        };\n    }\n\n    /**\n     * Submit a pre-signed transaction.\n     *\n     * The generic type T flows from prepareForSigning() for type documentation.\n     */\n    async submitSigned(\n        prepared: PreparedTransaction,\n        signatures: ExternalSignature[],\n    ): Promise<SubmitResult> {\n        // Snapshot ledger end so the caller can poll for completion from this point\n        const completionOffset = await this.getLedgerEndOffset();\n\n        const request: PostV2InteractiveSubmissionExecuteRequest = {\n            jsExecuteSubmissionRequest: {\n                preparedTransaction: prepared.preparedTransaction,\n                // Map each ExternalSignature into the Canton per-party signature format\n                partySignatures: {\n                    signatures: signatures.map((sig) => ({\n                        party: sig.party,\n                        signatures: [\n                            {\n                                format: sig.format,\n                                signature: sig.signature,\n                                signedBy: sig.signedBy,\n                                signingAlgorithmSpec: sig.signingAlgorithmSpec,\n                            },\n                        ],\n                    })),\n                },\n                deduplicationPeriod: {\n                    deduplicationDuration: {\n                        value: { seconds: 3600, nanos: 0 }, // 1 hour default\n                    },\n                },\n                submissionId: randomUUID(),\n                userId: this.#userId,\n                hashingSchemeVersion: prepared.hashingSchemeVersion,\n            },\n        };\n\n        await this.#invoke(() => this.#api.postV2InteractiveSubmissionExecute(request));\n\n        return { commandId: prepared.commandId, completionOffset };\n    }\n\n    // ─────────────────────────────────────────────────────────────────────────\n    // Active Contracts Query\n    // ─────────────────────────────────────────────────────────────────────────\n\n    /**\n     * Get the current ledger end offset.\n     */\n    async getLedgerEndOffset(): Promise<number> {\n        const response = await this.#invoke(() => this.#api.getV2StateLedgerEnd());\n        return response.offset ?? 0;\n    }\n\n    /**\n     * Query active contracts at a given offset with optional template filtering.\n     *\n     * @param party - Party to query as\n     * @param offset - Ledger offset for the snapshot\n     * @param opts.templateIds - Optional template IDs to filter by\n     * @param opts.limit - Maximum number of contracts to return\n     * @param opts.includeCreatedEventBlob - Include CIP disclosure blobs (default false)\n     */\n    async queryActiveContracts(\n        party: string,\n        offset: number,\n        opts?: { templateIds?: string[]; limit?: number; includeCreatedEventBlob?: boolean },\n    ): Promise<JsActiveContract[]> {\n        return this.queryActiveContractsByParties([party], offset, opts?.templateIds ?? [], {\n            limit: opts?.limit,\n            includeCreatedEventBlob: opts?.includeCreatedEventBlob,\n        });\n    }\n\n    /**\n     * Query active contracts visible to any of the given parties.\n     *\n     * Single API call with all parties in filtersByParty.\n     *\n     * @param parties - Parties to query as (for visibility)\n     * @param offset - Ledger offset for the snapshot\n     * @param templateIds - Template IDs to filter by\n     * @param opts.limit - Maximum number of contracts to return\n     * @param opts.includeCreatedEventBlob - Include CIP disclosure blobs (default false)\n     */\n    async queryActiveContractsByParties(\n        parties: string[],\n        offset: number,\n        templateIds: string[],\n        opts?: { limit?: number; includeCreatedEventBlob?: boolean },\n    ): Promise<JsActiveContract[]> {\n        return this.#fetchActiveContracts(\n            parties,\n            offset,\n            this.#buildCumulativeFilters(templateIds, opts?.includeCreatedEventBlob),\n            opts,\n        );\n    }\n\n    /**\n     * Query active contracts visible to any of the given parties that implement\n     * the given interfaces.\n     *\n     * @param parties - Parties to query as (for visibility)\n     * @param offset - Ledger offset for the snapshot\n     * @param interfaceIds - Interface IDs to filter by (e.g. \"#package:Module:Interface\")\n     * @param opts.limit - Maximum number of contracts to return\n     */\n    async queryActiveContractsByInterface(\n        parties: string[],\n        offset: number,\n        interfaceIds: string[],\n        opts?: { limit?: number; includeCreatedEventBlob?: boolean },\n    ): Promise<JsActiveContract[]> {\n        return this.#fetchActiveContracts(\n            parties,\n            offset,\n            this.#buildInterfaceCumulativeFilters(interfaceIds, opts?.includeCreatedEventBlob),\n            opts,\n        );\n    }\n\n    async #fetchActiveContracts(\n        parties: string[],\n        offset: number,\n        cumulativeFilter: CumulativeFilter[],\n        opts?: { limit?: number },\n    ): Promise<JsActiveContract[]> {\n        const filtersByParty = Object.fromEntries(\n            parties.map((party) => [party, { cumulative: cumulativeFilter }]),\n        );\n\n        // `eventFormat` replaces the legacy `filter` + `verbose: true` fields, which Canton 3.6\n        // rejects by default (DEPRECATED_API_DISABLED) and 3.7 removes.\n        const rawResponse = await this.#invoke(() =>\n            this.#api.postV2StateActiveContractsRaw({\n                getActiveContractsRequest: {\n                    eventFormat: { filtersByParty, verbose: false },\n                    activeAtOffset: offset,\n                },\n                limit: opts?.limit,\n            }),\n        );\n\n        // Raw response is an array of streamed entries; extract and deserialize contracts\n        type RawActiveContractsResponse = Array<{\n            contractEntry?: { JsActiveContract?: Record<string, unknown> };\n        }>;\n        const rawJson: RawActiveContractsResponse = await rawResponse.raw.json();\n\n        return rawJson\n            .map((item) => item.contractEntry?.JsActiveContract)\n            .filter((contract): contract is Record<string, unknown> => contract != null)\n            .map((contract) => JsActiveContractFromJSON(contract));\n    }\n\n    /**\n     * Stream transactions from a given offset.\n     *\n     * Uses `updateFormat` with `TRANSACTION_SHAPE_LEDGER_EFFECTS` so consumers\n     * receive `ExercisedEvent`s (e.g. the request-poller depends on\n     * `Request_Create` exercise results). The deprecated legacy `filter`\n     * shape would default to `ACS_DELTA`, which only emits Created/Archived\n     * events and silently drops every exercise on the wire.\n     *\n     * @param party - Party to query as\n     * @param beginExclusive - Start offset (exclusive)\n     * @param endInclusive - End offset (inclusive)\n     * @param opts.templateIds - Optional template IDs to filter by\n     * @param opts.limit - Maximum number of transactions to return\n     */\n    async getUpdates(\n        party: string,\n        beginExclusive: number,\n        endInclusive: number,\n        opts?: { templateIds?: string[]; limit?: number },\n    ): Promise<CantonUpdate[]> {\n        const eventFormat = {\n            filtersByParty: {\n                [party]: { cumulative: this.#buildCumulativeFilters(opts?.templateIds) },\n            },\n            verbose: false,\n        };\n        const rawResponse = await this.#invoke(() =>\n            this.#api.postV2UpdatesRaw({\n                getUpdatesRequest: {\n                    beginExclusive,\n                    endInclusive,\n                    updateFormat: {\n                        includeTransactions: {\n                            eventFormat,\n                            transactionShape: 'TRANSACTION_SHAPE_LEDGER_EFFECTS' as const,\n                        },\n                    },\n                },\n                limit: opts?.limit,\n            }),\n        );\n\n        const updateResponses: CantonUpdateResponse[] = await rawResponse.raw.json();\n\n        return updateResponses.map((response) => response.update);\n    }\n\n    /**\n     * Build cumulative filters for party-based queries.\n     * If templateIds provided, filters by those templates; otherwise uses wildcard.\n     */\n    #buildCumulativeFilters(\n        templateIds?: string[],\n        includeCreatedEventBlob = false,\n    ): CumulativeFilter[] {\n        if (templateIds?.length) {\n            return templateIds.map((templateId) => ({\n                identifierFilter: {\n                    templateFilter: { value: { templateId, includeCreatedEventBlob } },\n                },\n            }));\n        }\n        return [\n            {\n                identifierFilter: {\n                    wildcardFilter: { value: { includeCreatedEventBlob } },\n                },\n            },\n        ];\n    }\n\n    /**\n     * Build cumulative filters for interface-based ACS queries.\n     * If interfaceIds provided, filters by those interfaces; otherwise uses wildcard.\n     */\n    #buildInterfaceCumulativeFilters(\n        interfaceIds?: string[],\n        includeCreatedEventBlob = false,\n    ): CumulativeFilter[] {\n        if (interfaceIds?.length) {\n            return interfaceIds.map((interfaceId) => ({\n                identifierFilter: {\n                    interfaceFilter: {\n                        value: {\n                            interfaceId,\n                            includeInterfaceView: true,\n                            includeCreatedEventBlob,\n                        },\n                    },\n                },\n            }));\n        }\n        return [\n            {\n                identifierFilter: {\n                    wildcardFilter: { value: { includeCreatedEventBlob } },\n                },\n            },\n        ];\n    }\n\n    /**\n     * Build the standard update format for fetching transactions.\n     */\n    #buildUpdateFormat(parties: string[]) {\n        return {\n            includeTransactions: {\n                eventFormat: {\n                    filtersByParty: this.#buildPartyFilters(parties, false),\n                    verbose: false,\n                },\n                transactionShape: 'TRANSACTION_SHAPE_LEDGER_EFFECTS' as const,\n            },\n        };\n    }\n\n    /**\n     * Parse an update response and extract the transaction.\n     * The response structure is: { update: { Transaction: { value: CantonTransaction } } }\n     */\n    #parseTransactionFromUpdate(\n        json: CantonUpdateResponse,\n        notFoundMessage: string,\n    ): CantonTransaction {\n        // Update can be a Transaction, Reassignment, TopologyTransaction, or OffsetCheckpoint\n        if (!('Transaction' in json.update)) {\n            throw new CantonProtocolError(notFoundMessage);\n        }\n\n        return json.update.Transaction.value;\n    }\n}\n"]}

package/dist/L64D74BZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/refresh/registry-context.ts"],"names":["TEMPLATE_ID_DISCOVERY_REGISTRY","TRANSFER_FACTORY_RELATIVE_PATH","CONTEXT_PROBE_EXECUTE_BEFORE_WINDOW_MS","TRANSFER_FACTORY_MAX_SENDER_CREDENTIALS","MAX_RESPONSE_BYTES","textMapToRecord","map","entries","Array","isArray","filter","entry","length","Object","undefined","Error","String","fromEntries","key","value","nonEmptyString","z","string","min","factoryResponseSchema","object","factoryId","choiceContext","choiceContextData","values","record","unknown","optional","disclosedContracts","array","templateId","contractId","createdEventBlob","synchronizerId","assertSafeRegistryUrl","registryBaseUrl","opts","parsed","URL","label","username","password","protocol","toLowerCase","host","hostname","isLoopback","environment","postRegistryJson","url","body","options","signal","AbortSignal","timeout","timeoutMs","response","fetch","method","headers","redirect","JSON","stringify","reader","getReader","chunks","size","done","read","byteLength","cancel","probeName","push","releaseLock","ok","status","get","includes","bytes","Uint8Array","offset","chunk","set","data","parse","TextDecoder","decode","postFactoryContext","safeParse","success","fetchTransferInstructionRegistryContext","choice","base","endsWith","encodeURIComponent","toString","shape","excludeDebugFields","discoveryUrlsForAppUid","sdk","informee","appUid","registries","queryActiveContracts","templateIds","flatMap","registry","isTrustedOrigin","createdEvent","urlMap","createArgument","fetchTransferFactoryContext","instrumentId","sender","receiver","amount","inputHoldingCids","requestedAt","Date","toISOString","executeBefore","choiceArguments","expectedAdmin","admin","transfer","meta","extraArgs","context","fetchMergedTransferFactoryContext","receivers","probeOptions","uniqueReceivers","Set","sort","contexts","Promise","all","mergeTransferFactoryContexts","mergeChoiceContextValues","mergeDisclosedContracts","isAvList","tag","contractIdsFromAnyValue","discloseUtilityCredentials","choiceValue","party","kind","cids","cid","created","archived","fetchEventsByContractId","disclosure","createDisclosure","maps","merged","incoming","existing","seen","element","elementKey","has","add","contracts","byId","Map","contract","fetchCallbackHoldings","owner","interfaceId","queryActiveContractsByInterface","includeCreatedEventBlob","view","callbackInterfaceView","asset","id","lock","partyIdFromRegistryFingerprint","fingerprint","canonical","hints","fingerprintToHint","hint"],"mappings":"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","file":"L64D74BZ.js","sourcesContent":["import type { ContractId } from '@daml/types';\nimport { z } from 'zod';\n\nimport type { ChoiceContext, InstrumentId } from '../client/amulet';\nimport type { JsActiveContract } from '../open-api/models';\nimport type { CantonSdk } from '../sdk';\nimport type { CantonDisclosedContract } from '../transaction';\nimport { isTrustedOrigin } from '../trusted-origin';\nimport { callbackInterfaceView } from './callback-contracts';\n\nconst TEMPLATE_ID_DISCOVERY_REGISTRY =\n    '#layerzero-discovery-registry:DiscoveryRegistry:DiscoveryRegistry';\nconst TRANSFER_FACTORY_RELATIVE_PATH = 'registry/transfer-instruction/v1/transfer-factory';\nconst CONTEXT_PROBE_EXECUTE_BEFORE_WINDOW_MS = 60 * 60 * 1000;\nconst TRANSFER_FACTORY_MAX_SENDER_CREDENTIALS = 8;\nconst MAX_RESPONSE_BYTES = 256 * 1024;\n\nexport type TransferFactoryContext = {\n    factoryId: string;\n    choiceContext: ChoiceContext;\n    disclosedContracts: CantonDisclosedContract[];\n};\n\nconst textMapToRecord = (map: unknown): Record<string, string> => {\n    const entries = Array.isArray(map)\n        ? map.filter(\n              (entry): entry is [unknown, unknown] => Array.isArray(entry) && entry.length >= 2,\n          )\n        : map && typeof map === 'object'\n          ? Object.entries(map)\n          : map == null\n            ? []\n            : undefined;\n    if (!entries) throw new Error(`Unexpected Daml map shape: ${String(map)}`);\n    return Object.fromEntries(entries.map(([key, value]) => [String(key), String(value)]));\n};\n\nconst nonEmptyString = z.string().min(1);\nconst factoryResponseSchema = z.object({\n    factoryId: nonEmptyString,\n    choiceContext: z.object({\n        choiceContextData: z\n            .object({ values: z.record(z.string(), z.unknown()).optional() })\n            .optional(),\n        disclosedContracts: z\n            .array(\n                z.object({\n                    templateId: nonEmptyString,\n                    contractId: nonEmptyString,\n                    createdEventBlob: nonEmptyString,\n                    synchronizerId: nonEmptyString,\n                }),\n            )\n            .optional(),\n    }),\n});\n\nexport const assertSafeRegistryUrl = (\n    registryBaseUrl: string,\n    opts: { environment?: string; label: string },\n): URL => {\n    let parsed: URL;\n    try {\n        parsed = new URL(registryBaseUrl);\n    } catch {\n        throw new Error(`${opts.label} is not a valid URL`);\n    }\n    if (parsed.username !== '' || parsed.password !== '') {\n        throw new Error(`${opts.label} must not include credentials`);\n    }\n    const protocol = parsed.protocol.toLowerCase();\n    if (protocol === 'https:') return parsed;\n    const host = parsed.hostname.toLowerCase();\n    const isLoopback = host === 'localhost' || host === '127.0.0.1' || host === '::1';\n    if (opts.environment === 'sandbox' && protocol === 'http:' && isLoopback) return parsed;\n    throw new Error(\n        opts.environment === 'sandbox'\n            ? `${opts.label} must use https (http only allowed for localhost / 127.0.0.1 / ::1)`\n            : `${opts.label} must use https`,\n    );\n};\n\nexport const postRegistryJson = async (\n    url: string,\n    body: unknown,\n    options: { timeoutMs?: number; probeName: string; headers?: Record<string, string> },\n): Promise<unknown> => {\n    const signal = AbortSignal.timeout(options.timeoutMs ?? 10_000);\n    const response = await fetch(url, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json', ...options.headers },\n        signal,\n        redirect: 'error',\n        body: JSON.stringify(body),\n    });\n    const reader = response.body?.getReader();\n    const chunks: Uint8Array[] = [];\n    let size = 0;\n    try {\n        while (reader) {\n            const { done, value } = await reader.read();\n            if (done) break;\n            size += value.byteLength;\n            if (size > MAX_RESPONSE_BYTES) {\n                await reader.cancel();\n                throw new Error(\n                    `${options.probeName} response from ${url} exceeds ${MAX_RESPONSE_BYTES} bytes`,\n                );\n            }\n            chunks.push(value);\n        }\n    } finally {\n        reader?.releaseLock();\n    }\n    if (!response.ok) {\n        throw new Error(\n            `Failed to fetch ${options.probeName} context from ${url}: HTTP ${response.status}`,\n        );\n    }\n    if (!(response.headers.get('content-type') ?? '').toLowerCase().includes('application/json')) {\n        throw new Error(`${options.probeName} response from ${url} must be application/json`);\n    }\n    const bytes = new Uint8Array(size);\n    let offset = 0;\n    for (const chunk of chunks) {\n        bytes.set(chunk, offset);\n        offset += chunk.byteLength;\n    }\n    let data: unknown;\n    try {\n        data = JSON.parse(new TextDecoder().decode(bytes));\n    } catch {\n        throw new Error(`${options.probeName} response from ${url} is not valid JSON`);\n    }\n    return data;\n};\n\nexport const postFactoryContext = async (\n    url: string,\n    body: unknown,\n    options: { timeoutMs?: number; probeName: string; headers?: Record<string, string> },\n): Promise<TransferFactoryContext> => {\n    const parsed = factoryResponseSchema.safeParse(await postRegistryJson(url, body, options));\n    if (!parsed.success)\n        throw new Error(`${options.probeName} response from ${url} failed schema validation`);\n    return {\n        factoryId: parsed.data.factoryId,\n        choiceContext: { values: parsed.data.choiceContext.choiceContextData?.values ?? {} },\n        disclosedContracts: parsed.data.choiceContext.disclosedContracts ?? [],\n    };\n};\n\nexport const fetchTransferInstructionRegistryContext = async (\n    registryBaseUrl: string,\n    contractId: string,\n    choice: 'accept' | 'reject' | 'withdraw',\n    environment?: string,\n): Promise<Omit<TransferFactoryContext, 'factoryId'>> => {\n    assertSafeRegistryUrl(registryBaseUrl, {\n        environment,\n        label: 'transfer-instruction discovery URL',\n    });\n    const base = registryBaseUrl.endsWith('/') ? registryBaseUrl : `${registryBaseUrl}/`;\n    const url = new URL(\n        `registry/transfer-instruction/v1/${encodeURIComponent(contractId)}/choice-contexts/${choice}`,\n        base,\n    ).toString();\n    const parsed = factoryResponseSchema.shape.choiceContext.safeParse(\n        await postRegistryJson(\n            url,\n            { excludeDebugFields: true },\n            { probeName: `transfer-instruction ${choice}` },\n        ),\n    );\n    if (!parsed.success)\n        throw new Error(`transfer-instruction ${choice} response failed schema validation`);\n    return {\n        choiceContext: { values: parsed.data.choiceContextData?.values ?? {} },\n        disclosedContracts: parsed.data.disclosedContracts ?? [],\n    };\n};\n\nexport const discoveryUrlsForAppUid = async (\n    sdk: CantonSdk,\n    informee: string,\n    offset: number,\n    appUid: string,\n): Promise<string[]> => {\n    const registries = await sdk.queryActiveContracts(informee, offset, {\n        templateIds: [TEMPLATE_ID_DISCOVERY_REGISTRY],\n    });\n    return registries.flatMap((registry) => {\n        if (!isTrustedOrigin(registry.createdEvent, informee, 'handler')) {\n            return [];\n        }\n        const urlMap = textMapToRecord(\n            (registry.createdEvent.createArgument as { urlMap: unknown }).urlMap,\n        );\n        const url = urlMap[appUid];\n        return url ? [url] : [];\n    });\n};\n\nexport type FetchTransferFactoryContextOptions = {\n    environment?: string;\n    inputHoldingCids: string[];\n    sender: string;\n    receiver: string;\n    amount: string;\n    timeoutMs?: number;\n    requestedAt?: string;\n    executeBefore?: string;\n};\n\nexport type FetchMergedTransferFactoryContextOptions = Omit<\n    FetchTransferFactoryContextOptions,\n    'receiver'\n> & {\n    receivers: string[];\n};\n\nexport const fetchTransferFactoryContext = async (\n    registryBaseUrl: string,\n    instrumentId: InstrumentId,\n    options: FetchTransferFactoryContextOptions,\n): Promise<TransferFactoryContext> => {\n    assertSafeRegistryUrl(registryBaseUrl, {\n        environment: options.environment,\n        label: 'transfer-factory discovery URL',\n    });\n\n    const base = registryBaseUrl.endsWith('/') ? registryBaseUrl : `${registryBaseUrl}/`;\n    const url = new URL(TRANSFER_FACTORY_RELATIVE_PATH, base).toString();\n\n    const { sender, receiver, amount, inputHoldingCids } = options;\n\n    const requestedAt = options.requestedAt ?? new Date().toISOString();\n    const executeBefore =\n        options.executeBefore ??\n        new Date(Date.parse(requestedAt) + CONTEXT_PROBE_EXECUTE_BEFORE_WINDOW_MS).toISOString();\n\n    return postFactoryContext(\n        url,\n        {\n            choiceArguments: {\n                expectedAdmin: instrumentId.admin,\n                transfer: {\n                    sender,\n                    receiver,\n                    amount,\n                    instrumentId,\n                    requestedAt,\n                    executeBefore,\n                    inputHoldingCids,\n                    meta: { values: {} },\n                },\n                extraArgs: { context: { values: {} }, meta: { values: {} } },\n            },\n        },\n        { timeoutMs: options.timeoutMs, probeName: 'transfer-factory' },\n    );\n};\n\nexport const fetchMergedTransferFactoryContext = async (\n    registryBaseUrl: string,\n    instrumentId: InstrumentId,\n    options: FetchMergedTransferFactoryContextOptions,\n): Promise<TransferFactoryContext> => {\n    const { receivers, ...probeOptions } = options;\n    const uniqueReceivers = [...new Set(receivers)].sort();\n    if (uniqueReceivers.length === 0) {\n        throw new Error('fetchMergedTransferFactoryContext requires at least one receiver');\n    }\n\n    const contexts = await Promise.all(\n        uniqueReceivers.map((receiver) =>\n            fetchTransferFactoryContext(registryBaseUrl, instrumentId, {\n                ...probeOptions,\n                receiver,\n            }),\n        ),\n    );\n    return mergeTransferFactoryContexts(contexts);\n};\n\nexport const mergeTransferFactoryContexts = (\n    contexts: TransferFactoryContext[],\n): TransferFactoryContext => {\n    if (contexts.length === 0) {\n        throw new Error(\n            'mergeTransferFactoryContexts requires at least one transfer-factory context',\n        );\n    }\n\n    const factoryId = contexts[0]!.factoryId;\n    for (const context of contexts) {\n        if (context.factoryId !== factoryId) {\n            throw new Error(\n                `transfer-factory factoryId mismatch: ${factoryId} vs ${context.factoryId}`,\n            );\n        }\n    }\n\n    return {\n        factoryId,\n        choiceContext: {\n            values: mergeChoiceContextValues(\n                contexts.map((context) => context.choiceContext.values),\n            ),\n        },\n        disclosedContracts: mergeDisclosedContracts(\n            contexts.flatMap((context) => context.disclosedContracts),\n        ),\n    };\n};\n\nconst isAvList = (value: unknown): value is { tag: 'AV_List'; value: unknown[] } =>\n    value !== null &&\n    typeof value === 'object' &&\n    'tag' in value &&\n    value.tag === 'AV_List' &&\n    'value' in value &&\n    Array.isArray(value.value);\n\nexport const contractIdsFromAnyValue = (value: unknown): string[] => {\n    if (value == null || typeof value !== 'object' || !('tag' in value)) {\n        return [];\n    }\n    if (value.tag === 'AV_ContractId' && 'value' in value && typeof value.value === 'string') {\n        return [value.value];\n    }\n    if (isAvList(value)) {\n        return value.value.flatMap(contractIdsFromAnyValue);\n    }\n    return [];\n};\n\nexport const discloseUtilityCredentials = async (\n    sdk: CantonSdk,\n    choiceValue: unknown,\n    party: string,\n    kind: string,\n): Promise<CantonDisclosedContract[]> => {\n    const label = `${kind} credential`;\n    const cids = contractIdsFromAnyValue(choiceValue);\n    if (cids.length > TRANSFER_FACTORY_MAX_SENDER_CREDENTIALS) {\n        throw new Error(`${label} exceeds ${TRANSFER_FACTORY_MAX_SENDER_CREDENTIALS} CIDs`);\n    }\n    return Promise.all(\n        cids.map(async (cid) => {\n            const { created, archived } = await sdk.fetchEventsByContractId(cid, [party]);\n            if (!created || archived) throw new Error(`${label} ${cid} is missing or archived`);\n            if (!created.templateId.endsWith(':Utility.Credential.V0.Credential:Credential')) {\n                throw new Error(`${label} ${cid} is not the expected template`);\n            }\n            if (!isTrustedOrigin(created, party, 'holder')) {\n                throw new Error(`${label} ${cid} is not a trusted holder origin`);\n            }\n            const disclosure = await sdk.createDisclosure(cid as ContractId<object>, [party]);\n            if (!disclosure) throw new Error(`Failed to create disclosure for ${label}: ${cid}`);\n            return disclosure;\n        }),\n    );\n};\n\nconst mergeChoiceContextValues = (maps: ChoiceContext['values'][]): ChoiceContext['values'] => {\n    const merged: ChoiceContext['values'] = {};\n    for (const map of maps) {\n        for (const [key, incoming] of Object.entries(map)) {\n            const existing = merged[key];\n            if (existing === undefined) {\n                merged[key] = incoming;\n                continue;\n            }\n            if (isAvList(existing) && isAvList(incoming)) {\n                const seen = new Set(existing.value.map((element) => JSON.stringify(element)));\n                const value = [...existing.value];\n                for (const element of incoming.value) {\n                    const elementKey = JSON.stringify(element);\n                    if (seen.has(elementKey)) continue;\n                    seen.add(elementKey);\n                    value.push(element);\n                }\n                merged[key] = { tag: 'AV_List', value };\n                continue;\n            }\n            if (JSON.stringify(existing) !== JSON.stringify(incoming)) {\n                throw new Error(\n                    `transfer-factory choice context key \"${key}\" has conflicting values`,\n                );\n            }\n        }\n    }\n    return merged;\n};\n\nexport const mergeDisclosedContracts = (\n    contracts: CantonDisclosedContract[],\n): CantonDisclosedContract[] => {\n    const byId = new Map<string, CantonDisclosedContract>();\n    for (const contract of contracts) {\n        const existing = byId.get(contract.contractId);\n        if (!existing) {\n            byId.set(contract.contractId, contract);\n            continue;\n        }\n        if (\n            existing.createdEventBlob !== contract.createdEventBlob ||\n            existing.templateId !== contract.templateId ||\n            existing.synchronizerId !== contract.synchronizerId\n        ) {\n            throw new Error(\n                `transfer-factory disclosed contract ${contract.contractId} has conflicting disclosure`,\n            );\n        }\n    }\n    return [...byId.values()];\n};\n\nexport const fetchCallbackHoldings = async (\n    sdk: CantonSdk,\n    owner: string,\n    offset: number,\n    instrumentId: InstrumentId,\n): Promise<JsActiveContract[]> => {\n    const interfaceId = '#splice-api-token-holding-v1:Splice.Api.Token.HoldingV1:Holding';\n    const contracts = await sdk.queryActiveContractsByInterface([owner], offset, [interfaceId], {\n        includeCreatedEventBlob: true,\n    });\n    return contracts.filter((contract) => {\n        const view = callbackInterfaceView(contract, interfaceId);\n        const asset = view?.instrumentId as { admin?: unknown; id?: unknown } | undefined;\n        return (\n            view?.owner === owner &&\n            asset?.admin === instrumentId.admin &&\n            asset?.id === instrumentId.id &&\n            view.lock == null\n        );\n    });\n};\n\nexport const partyIdFromRegistryFingerprint = (\n    registry: { fingerprintToHint: unknown },\n    fingerprint: string,\n): string => {\n    const canonical = fingerprint.toLowerCase();\n    const hints = textMapToRecord(registry.fingerprintToHint);\n    const hint = hints[canonical] ?? hints[fingerprint];\n    if (!hint) throw new Error(`Fingerprint ${canonical} not found in registry fingerprintToHint`);\n    return `${hint}::1220${canonical}`;\n};\n"]}

package/dist/Q3BYU6GJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/refresh/select-contracts.ts"],"names":["DAML_DECIMAL_SCALE","MAX_SELECTED_CONTRACTS","parseDamlDecimal","value","label","Error","match","exec","sign","whole","BigInt","fraction","padEnd","selectContractAmounts","contracts","field","requestedValue","amountOf","requested","candidates","map","contract","amount","filter","sort","left","right","createdEvent","contractId","localeCompare","selected","total","candidate","push","toString","length"],"mappings":"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","file":"Q3BYU6GJ.js","sourcesContent":["import type { JsActiveContract } from '../open-api/models';\n\nconst DAML_DECIMAL_SCALE = 10n ** 10n;\nconst MAX_SELECTED_CONTRACTS = 100;\n\nexport const parseDamlDecimal = (value: unknown, label: string): bigint => {\n    if (typeof value !== 'string') {\n        throw new Error(`${label} must be a DAML Decimal string`);\n    }\n    const match = /^([+-]?)(\\d+)(?:\\.(\\d{0,10}))?$/.exec(value);\n    if (!match) {\n        throw new Error(`${label} is not a valid DAML Decimal: ${value}`);\n    }\n    const sign = match[1] === '-' ? -1n : 1n;\n    const whole = BigInt(match[2]!);\n    const fraction = BigInt((match[3] ?? '').padEnd(10, '0'));\n    return sign * (whole * DAML_DECIMAL_SCALE + fraction);\n};\n\nexport const selectContractAmounts = (\n    contracts: JsActiveContract[],\n    field: string,\n    requestedValue: string,\n    amountOf: (contract: JsActiveContract) => bigint,\n): JsActiveContract[] => {\n    const requested = parseDamlDecimal(requestedValue, 'Requested contract value');\n    if (requested <= 0n) {\n        throw new Error('Requested contract value must be positive');\n    }\n\n    const candidates = contracts\n        .map((contract) => ({\n            contract,\n            amount: amountOf(contract),\n        }))\n        .filter(({ amount }) => amount > 0n)\n        .sort((left, right) =>\n            left.amount === right.amount\n                ? left.contract.createdEvent.contractId.localeCompare(\n                      right.contract.createdEvent.contractId,\n                  )\n                : left.amount > right.amount\n                  ? -1\n                  : 1,\n        );\n\n    const selected: JsActiveContract[] = [];\n    let total = 0n;\n    for (const candidate of candidates) {\n        selected.push(candidate.contract);\n        total += candidate.amount;\n        if (total >= requested) break;\n    }\n\n    if (total < requested) {\n        throw new Error(\n            `Insufficient contract value in field ${field}: requested ${requestedValue}, found ${total.toString()} base units`,\n        );\n    }\n    if (selected.length > MAX_SELECTED_CONTRACTS) {\n        throw new Error(\n            `Selection needs ${selected.length} contracts, exceeding the ${MAX_SELECTED_CONTRACTS} input limit`,\n        );\n    }\n    return selected;\n};\n"]}