@fairmint/canton-node-sdk 0.0.241 → 0.0.243

package/build/src/utils/token-standard/v2/allocation-state.js

@@ -0,0 +1,638 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenStandardV2AllocationStateError = exports.TokenStandardV2AllocationStateErrorCode = exports.TOKEN_STANDARD_V2_ALLOCATION_INSTRUCTION_INTERFACE_ID = exports.TOKEN_STANDARD_V2_ALLOCATION_INTERFACE_ID = void 0;
+exports.getTokenStandardV2AllocationViewsByContractIds = getTokenStandardV2AllocationViewsByContractIds;
+exports.discoverTokenStandardV2AllocationState = discoverTokenStandardV2AllocationState;
+const errors_1 = require("../../../core/errors");
+const utils_1 = require("../../../core/utils");
+const contracts_1 = require("../../contracts");
+exports.TOKEN_STANDARD_V2_ALLOCATION_INTERFACE_ID = '#splice-api-token-allocation-v2:Splice.Api.Token.AllocationV2:Allocation';
+exports.TOKEN_STANDARD_V2_ALLOCATION_INSTRUCTION_INTERFACE_ID = '#splice-api-token-allocation-instruction-v2:Splice.Api.Token.AllocationInstructionV2:AllocationInstruction';
+exports.TokenStandardV2AllocationStateErrorCode = {
+    INPUT_INVALID: 'TOKEN_STANDARD_V2_ALLOCATION_STATE_INPUT_INVALID',
+    INTERFACE_VIEW_INVALID: 'TOKEN_STANDARD_V2_ALLOCATION_STATE_INTERFACE_VIEW_INVALID',
+    ACS_INCOMPLETE: 'TOKEN_STANDARD_V2_ALLOCATION_STATE_ACS_INCOMPLETE',
+    AMBIGUOUS: 'TOKEN_STANDARD_V2_ALLOCATION_STATE_AMBIGUOUS',
+    NOT_FOUND: 'TOKEN_STANDARD_V2_ALLOCATION_STATE_NOT_FOUND',
+};
+/** Typed failure raised while recovering a Token Standard V2 allocation state from the ACS. */
+class TokenStandardV2AllocationStateError extends errors_1.CantonError {
+    constructor(code, message, context) {
+        super(message, code, context);
+        this.name = 'TokenStandardV2AllocationStateError';
+    }
+}
+exports.TokenStandardV2AllocationStateError = TokenStandardV2AllocationStateError;
+function inputInvalid(message, context) {
+    throw new TokenStandardV2AllocationStateError(exports.TokenStandardV2AllocationStateErrorCode.INPUT_INVALID, message, context);
+}
+function interfaceViewInvalid(message, context) {
+    throw new TokenStandardV2AllocationStateError(exports.TokenStandardV2AllocationStateErrorCode.INTERFACE_VIEW_INVALID, message, context);
+}
+function acsIncomplete(message, context) {
+    throw new TokenStandardV2AllocationStateError(exports.TokenStandardV2AllocationStateErrorCode.ACS_INCOMPLETE, message, context);
+}
+function notFound(message, context) {
+    throw new TokenStandardV2AllocationStateError(exports.TokenStandardV2AllocationStateErrorCode.NOT_FOUND, message, context);
+}
+function requireTrimmedNonEmpty(value, field, invalid) {
+    if (!(0, utils_1.isNonEmptyString)(value)) {
+        invalid(`${field} must be a non-empty string.`, { field, value });
+    }
+    return value.trim();
+}
+function requireText(value, field, invalid) {
+    if (typeof value !== 'string') {
+        invalid(`${field} must be a string.`, { field, value });
+    }
+    return value;
+}
+function readNullableNonEmptyString(value, field, invalid) {
+    return value === null || value === undefined ? null : requireTrimmedNonEmpty(value, field, invalid);
+}
+function mapDenseArray(value, field, invalid, transform) {
+    const result = [];
+    for (let index = 0; index < value.length; index += 1) {
+        if (!(index in value)) {
+            invalid(`${field} must not contain missing elements.`, { field: `${field}[${index}]` });
+        }
+        result.push(transform(value[index], index));
+    }
+    return result;
+}
+function readStringArray(value, field, invalid, options) {
+    if (!Array.isArray(value) || (!options.allowEmpty && value.length === 0)) {
+        invalid(`${field} must be ${options.allowEmpty ? 'an array' : 'a non-empty array'}.`, { field, value });
+    }
+    return mapDenseArray(value, field, invalid, (item, index) => {
+        const itemField = `${field}[${index}]`;
+        return options.trim ? requireTrimmedNonEmpty(item, itemField, invalid) : requireText(item, itemField, invalid);
+    });
+}
+function createReadonlyStringRecord(entries) {
+    const result = Object.create(null);
+    for (const [key, value] of entries) {
+        Object.defineProperty(result, key, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: false,
+        });
+    }
+    return result;
+}
+function readMetadata(value, field, invalid) {
+    if (!(0, utils_1.isRecord)(value) || !(0, utils_1.isRecord)(value['values'])) {
+        invalid(`${field} must contain a values record.`, { field, value });
+    }
+    const entries = Object.entries(value['values']).map(([key, metadataValue]) => {
+        if (typeof metadataValue !== 'string') {
+            invalid(`${field}.values must contain only strings.`, { field, key, value: metadataValue });
+        }
+        return [key, metadataValue];
+    });
+    return { values: createReadonlyStringRecord(entries) };
+}
+function readAccount(value, field, invalid) {
+    if (!(0, utils_1.isRecord)(value)) {
+        invalid(`${field} must be a Token Standard V2 account.`, { field, value });
+    }
+    return {
+        owner: readNullableNonEmptyString(value['owner'], `${field}.owner`, invalid),
+        provider: readNullableNonEmptyString(value['provider'], `${field}.provider`, invalid),
+        id: requireText(value['id'], `${field}.id`, invalid),
+    };
+}
+function readDecimal(value, field, invalid, allowZero) {
+    const text = requireText(value, field, invalid);
+    const match = /^(\d{1,28})(?:\.(\d{1,10}))?$/.exec(text);
+    if (!match || (!allowZero && /^0+$/.test(`${match[1]}${match[2] ?? ''}`))) {
+        invalid(`${field} must be a ${allowZero ? 'non-negative' : 'positive'} Daml Decimal string.`, {
+            field,
+            value,
+        });
+    }
+    return text;
+}
+function readDecimalMap(value, field, invalid) {
+    if (value === null || value === undefined)
+        return null;
+    if (!(0, utils_1.isRecord)(value)) {
+        invalid(`${field} must be null or a decimal map.`, { field, value });
+    }
+    return createReadonlyStringRecord(Object.entries(value).map(([key, amount]) => [key, readDecimal(amount, `${field}.${key}`, invalid, false)]));
+}
+function readSettlement(value, field, invalid) {
+    if (!(0, utils_1.isRecord)(value)) {
+        invalid(`${field} must be a settlement record.`, { field, value });
+    }
+    return {
+        executors: readStringArray(value['executors'], `${field}.executors`, invalid, {
+            allowEmpty: false,
+            trim: true,
+        }),
+        id: requireText(value['id'], `${field}.id`, invalid),
+        cid: readNullableNonEmptyString(value['cid'], `${field}.cid`, invalid),
+        meta: readMetadata(value['meta'], `${field}.meta`, invalid),
+    };
+}
+function readAllocation(value, field, invalid) {
+    if (!(0, utils_1.isRecord)(value) || !Array.isArray(value['transferLegSides'])) {
+        invalid(`${field} must be an allocation record.`, { field, value });
+    }
+    const transferLegSides = mapDenseArray(value['transferLegSides'], `${field}.transferLegSides`, invalid, (transferLegSide, index) => {
+        const legField = `${field}.transferLegSides[${index}]`;
+        if (!(0, utils_1.isRecord)(transferLegSide)) {
+            invalid(`${legField} must be a transfer-leg side.`, { field: legField, value: transferLegSide });
+        }
+        const { side } = transferLegSide;
+        if (side !== 'SenderSide' && side !== 'ReceiverSide') {
+            invalid(`${legField}.side must be SenderSide or ReceiverSide.`, {
+                field: `${legField}.side`,
+                value: side,
+            });
+        }
+        const normalizedSide = side === 'SenderSide' ? 'SenderSide' : 'ReceiverSide';
+        return {
+            transferLegId: requireText(transferLegSide['transferLegId'], `${legField}.transferLegId`, invalid),
+            side: normalizedSide,
+            otherside: readAccount(transferLegSide['otherside'], `${legField}.otherside`, invalid),
+            amount: readDecimal(transferLegSide['amount'], `${legField}.amount`, invalid, false),
+            instrumentId: requireText(transferLegSide['instrumentId'], `${legField}.instrumentId`, invalid),
+            meta: readMetadata(transferLegSide['meta'], `${legField}.meta`, invalid),
+        };
+    });
+    const transferLegSideKeys = transferLegSides.map(({ side, transferLegId }) => JSON.stringify([transferLegId, side]));
+    if (new Set(transferLegSideKeys).size !== transferLegSideKeys.length) {
+        invalid(`${field}.transferLegSides must not contain duplicate transfer-leg sides.`, {
+            field: `${field}.transferLegSides`,
+        });
+    }
+    const nextIterationFunding = readDecimalMap(value['nextIterationFunding'], `${field}.nextIterationFunding`, invalid);
+    if (transferLegSides.length === 0 && nextIterationFunding === null) {
+        invalid(`${field}.transferLegSides may be empty only when iterated settlement is enabled.`, {
+            field: `${field}.transferLegSides`,
+        });
+    }
+    if (typeof value['committed'] !== 'boolean') {
+        invalid(`${field}.committed must be a boolean.`, { field: `${field}.committed`, value: value['committed'] });
+    }
+    return {
+        admin: requireTrimmedNonEmpty(value['admin'], `${field}.admin`, invalid),
+        authorizer: readAccount(value['authorizer'], `${field}.authorizer`, invalid),
+        transferLegSides,
+        settlementDeadline: readNullableNonEmptyString(value['settlementDeadline'], `${field}.settlementDeadline`, invalid),
+        nextIterationFunding,
+        committed: value['committed'],
+        meta: readMetadata(value['meta'], `${field}.meta`, invalid),
+    };
+}
+function readRequest(value) {
+    if (!(0, utils_1.isRecord)(value)) {
+        inputInvalid('request must be a Token Standard V2 allocation request.', { field: 'request', value });
+    }
+    return {
+        settlement: readSettlement(value['settlement'], 'request.settlement', inputInvalid),
+        allocation: readAllocation(value['allocation'], 'request.allocation', inputInvalid),
+        requestedAt: requireTrimmedNonEmpty(value['requestedAt'], 'request.requestedAt', inputInvalid),
+        inputHoldingCids: readStringArray(value['inputHoldingCids'], 'request.inputHoldingCids', inputInvalid, {
+            allowEmpty: true,
+            trim: true,
+        }),
+    };
+}
+function readNonNegativeInteger(value, field, invalid) {
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
+        return value.toString();
+    if (typeof value === 'string' && /^\d+$/.test(value))
+        return BigInt(value).toString();
+    invalid(`${field} must be a non-negative integer.`, { field, value });
+}
+function readAllocationViewIdentity(value, context) {
+    if (!(0, utils_1.isRecord)(value)) {
+        interfaceViewInvalid('AllocationV2 interface view must be a record.', context);
+    }
+    const invalid = (message, fieldContext) => interfaceViewInvalid(message, { ...context, ...fieldContext });
+    return {
+        value,
+        settlement: readSettlement(value['settlement'], 'view.settlement', invalid),
+        allocation: readAllocation(value['allocation'], 'view.allocation', invalid),
+    };
+}
+function readAllocationView(identity, context) {
+    const { value } = identity;
+    if (!('availableActions' in value)) {
+        interfaceViewInvalid('AllocationV2 interface view is missing availableActions.', context);
+    }
+    const invalid = (message, fieldContext) => interfaceViewInvalid(message, { ...context, ...fieldContext });
+    return {
+        originalAllocationCid: readNullableNonEmptyString(value['originalAllocationCid'], 'view.originalAllocationCid', invalid),
+        settlement: identity.settlement,
+        allocation: identity.allocation,
+        holdingCids: readStringArray(value['holdingCids'], 'view.holdingCids', invalid, {
+            allowEmpty: true,
+            trim: true,
+        }),
+        createdAt: requireTrimmedNonEmpty(value['createdAt'], 'view.createdAt', invalid),
+        numIterations: readNonNegativeInteger(value['numIterations'], 'view.numIterations', invalid),
+        expiresAt: readNullableNonEmptyString(value['expiresAt'], 'view.expiresAt', invalid),
+        availableActions: value['availableActions'],
+        meta: readMetadata(value['meta'], 'view.meta', invalid),
+    };
+}
+function readAllocationInstructionViewIdentity(value, context) {
+    if (!(0, utils_1.isRecord)(value)) {
+        interfaceViewInvalid('AllocationInstructionV2 interface view must be a record.', context);
+    }
+    const invalid = (message, fieldContext) => interfaceViewInvalid(message, { ...context, ...fieldContext });
+    return {
+        value,
+        settlement: readSettlement(value['settlement'], 'view.settlement', invalid),
+        allocation: readAllocation(value['allocation'], 'view.allocation', invalid),
+        requestedAt: requireTrimmedNonEmpty(value['requestedAt'], 'view.requestedAt', invalid),
+        inputHoldingCids: readStringArray(value['inputHoldingCids'], 'view.inputHoldingCids', invalid, {
+            allowEmpty: true,
+            trim: true,
+        }),
+    };
+}
+function readAllocationInstructionView(identity, context) {
+    const { value } = identity;
+    if (!('availableActions' in value)) {
+        interfaceViewInvalid('AllocationInstructionV2 interface view is missing availableActions.', context);
+    }
+    const invalid = (message, fieldContext) => interfaceViewInvalid(message, { ...context, ...fieldContext });
+    return {
+        originalInstructionCid: readNullableNonEmptyString(value['originalInstructionCid'], 'view.originalInstructionCid', invalid),
+        settlement: identity.settlement,
+        allocation: identity.allocation,
+        requestedAt: identity.requestedAt,
+        inputHoldingCids: identity.inputHoldingCids,
+        expiresAt: readNullableNonEmptyString(value['expiresAt'], 'view.expiresAt', invalid),
+        availableActions: value['availableActions'],
+        meta: readMetadata(value['meta'], 'view.meta', invalid),
+    };
+}
+function identifierModuleEntitySuffix(identifier) {
+    const separator = identifier.indexOf(':');
+    return separator === -1 ? undefined : identifier.slice(separator + 1);
+}
+function interfaceIdsMatch(left, right) {
+    return identifierModuleEntitySuffix(left) === identifierModuleEntitySuffix(right);
+}
+function arraysEqual(left, right, equal) {
+    if (left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length; index += 1) {
+        if (!(index in left) || !(index in right) || !equal(left[index], right[index]))
+            return false;
+    }
+    return true;
+}
+function stringArraysEqual(left, right) {
+    return arraysEqual(left, right, (a, b) => a === b);
+}
+function metadataEqual(left, right) {
+    const leftKeys = Object.keys(left.values).sort();
+    const rightKeys = Object.keys(right.values).sort();
+    return stringArraysEqual(leftKeys, rightKeys) && leftKeys.every((key) => left.values[key] === right.values[key]);
+}
+function canonicalDecimal(value) {
+    const match = /^(\d+)(?:\.(\d+))?$/.exec(value);
+    if (!match)
+        return undefined;
+    const whole = (match[1] ?? '').replace(/^0+(?=\d)/, '');
+    const fraction = (match[2] ?? '').replace(/0+$/, '');
+    return fraction.length === 0 ? whole : `${whole}.${fraction}`;
+}
+function decimalsEqual(left, right) {
+    const canonicalLeft = canonicalDecimal(left);
+    const canonicalRight = canonicalDecimal(right);
+    return canonicalLeft !== undefined && canonicalLeft === canonicalRight;
+}
+function decimalMapsEqual(left, right) {
+    if (left === null || right === null)
+        return left === right;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return (stringArraysEqual(leftKeys, rightKeys) &&
+        leftKeys.every((key) => right[key] !== undefined && decimalsEqual(left[key], right[key])));
+}
+function canonicalTimestamp(value) {
+    const match = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?Z$/.exec(value);
+    if (!match)
+        return undefined;
+    const milliseconds = Date.parse(`${match[1]}Z`);
+    if (!Number.isFinite(milliseconds))
+        return undefined;
+    const microseconds = match[2]?.padEnd(6, '0') ?? '000000';
+    return BigInt(milliseconds) * 1000n + BigInt(microseconds);
+}
+function timestampsEqual(left, right) {
+    if (left === null || right === null)
+        return left === right;
+    const canonicalLeft = canonicalTimestamp(left);
+    const canonicalRight = canonicalTimestamp(right);
+    return canonicalLeft === undefined || canonicalRight === undefined
+        ? left === right
+        : canonicalLeft === canonicalRight;
+}
+function accountsEqual(left, right) {
+    return left.owner === right.owner && left.provider === right.provider && left.id === right.id;
+}
+function settlementsEqual(left, right) {
+    return (stringArraysEqual(left.executors, right.executors) &&
+        left.id === right.id &&
+        left.cid === right.cid &&
+        metadataEqual(left.meta, right.meta));
+}
+function allocationsEqual(left, right) {
+    return (left.admin === right.admin &&
+        accountsEqual(left.authorizer, right.authorizer) &&
+        arraysEqual(left.transferLegSides, right.transferLegSides, (leftLeg, rightLeg) => Boolean(leftLeg.transferLegId === rightLeg.transferLegId &&
+            leftLeg.side === rightLeg.side &&
+            accountsEqual(leftLeg.otherside, rightLeg.otherside) &&
+            decimalsEqual(leftLeg.amount, rightLeg.amount) &&
+            leftLeg.instrumentId === rightLeg.instrumentId &&
+            metadataEqual(leftLeg.meta, rightLeg.meta))) &&
+        timestampsEqual(left.settlementDeadline, right.settlementDeadline) &&
+        decimalMapsEqual(left.nextIterationFunding, right.nextIterationFunding) &&
+        left.committed === right.committed &&
+        metadataEqual(left.meta, right.meta));
+}
+function unknownValuesEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right) && arraysEqual(left, right, unknownValuesEqual);
+    }
+    if (!(0, utils_1.isRecord)(left) || !(0, utils_1.isRecord)(right))
+        return false;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return stringArraysEqual(leftKeys, rightKeys) && leftKeys.every((key) => unknownValuesEqual(left[key], right[key]));
+}
+function setConsistentState(states, contractId, state) {
+    const existing = states.get(contractId);
+    if (existing && !unknownValuesEqual(existing, state)) {
+        interfaceViewInvalid('Duplicate allocation-state rows contain inconsistent data.', { contractId });
+    }
+    if (!existing)
+        states.set(contractId, state);
+}
+function allocationRequestCoreMatches(request, view) {
+    return settlementsEqual(request.settlement, view.settlement) && allocationsEqual(request.allocation, view.allocation);
+}
+function normalizeParties(parties) {
+    if (!Array.isArray(parties)) {
+        inputInvalid('parties must be an array of explicit read parties.', { field: 'parties' });
+    }
+    const normalized = new Set();
+    for (const [index, party] of parties.entries()) {
+        normalized.add(requireTrimmedNonEmpty(party, `parties[${index}]`, inputInvalid));
+    }
+    if (normalized.size === 0) {
+        inputInvalid('parties must contain at least one explicit read party.', { field: 'parties' });
+    }
+    return [...normalized];
+}
+function normalizeActiveAtOffset(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        inputInvalid('activeAtOffset must be a non-negative safe integer.', {
+            field: 'activeAtOffset',
+            activeAtOffset: value,
+        });
+    }
+    return value;
+}
+function normalizeAllocationCids(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        inputInvalid('allocationCids must be a non-empty array.', {
+            field: 'allocationCids',
+            allocationCids: value,
+        });
+    }
+    const allocationCids = mapDenseArray(value, 'allocationCids', inputInvalid, (contractId, index) => requireTrimmedNonEmpty(contractId, `allocationCids[${index}]`, inputInvalid));
+    if (new Set(allocationCids).size !== allocationCids.length) {
+        inputInvalid('allocationCids must not contain duplicates.', {
+            field: 'allocationCids',
+            allocationCids,
+        });
+    }
+    return allocationCids;
+}
+function handleNonActiveContractItem(item, itemIndex, synchronizerId) {
+    if (!(0, utils_1.isRecord)(item) || !(0, utils_1.isRecord)(item['contractEntry'])) {
+        interfaceViewInvalid('ACS response contains an invalid contract row.', { itemIndex });
+    }
+    const { contractEntry } = item;
+    if ('JsEmpty' in contractEntry)
+        return;
+    const incompleteAssigned = contractEntry['JsIncompleteAssigned'];
+    if ((0, utils_1.isRecord)(incompleteAssigned) && (0, utils_1.isRecord)(incompleteAssigned['assignedEvent'])) {
+        const { assignedEvent } = incompleteAssigned;
+        if (assignedEvent['source'] !== synchronizerId && assignedEvent['target'] !== synchronizerId)
+            return;
+        acsIncomplete('Allocation state is incomplete while its contract is being reassigned.', {
+            itemIndex,
+            contractId: assignedEvent['contractId'],
+            source: assignedEvent['source'],
+            target: assignedEvent['target'],
+        });
+    }
+    const incompleteUnassigned = contractEntry['JsIncompleteUnassigned'];
+    if ((0, utils_1.isRecord)(incompleteUnassigned) && (0, utils_1.isRecord)(incompleteUnassigned['unassignedEvent'])) {
+        const { unassignedEvent } = incompleteUnassigned;
+        if (unassignedEvent['source'] !== synchronizerId && unassignedEvent['target'] !== synchronizerId)
+            return;
+        acsIncomplete('Allocation state is incomplete while its contract is being reassigned.', {
+            itemIndex,
+            contractId: unassignedEvent['contractId'],
+            source: unassignedEvent['source'],
+            target: unassignedEvent['target'],
+        });
+    }
+    interfaceViewInvalid('ACS response contains an unsupported contract row.', { itemIndex });
+}
+/**
+ * Reads exact active AllocationV2 contracts from one ACS snapshot.
+ *
+ * Contract IDs and decoded views are returned together so callers cannot validate an off-ledger allocation snapshot and
+ * later submit a different contract ID.
+ */
+async function getTokenStandardV2AllocationViewsByContractIds(params) {
+    if (!(0, utils_1.isRecord)(params)) {
+        inputInvalid('params must be an exact allocation-view request.', { field: 'params' });
+    }
+    if (!(0, utils_1.isRecord)(params.ledger) || typeof params.ledger.getActiveContracts !== 'function') {
+        inputInvalid('ledger must provide getActiveContracts.', { field: 'ledger' });
+    }
+    const parties = normalizeParties(params.parties);
+    const synchronizerId = requireTrimmedNonEmpty(params.synchronizerId, 'synchronizerId', inputInvalid);
+    const allocationCids = normalizeAllocationCids(params.allocationCids);
+    const requestedCids = new Set(allocationCids);
+    const activeAtOffset = normalizeActiveAtOffset(params.activeAtOffset);
+    const response = await params.ledger.getActiveContracts({
+        parties,
+        interfaceIds: [exports.TOKEN_STANDARD_V2_ALLOCATION_INTERFACE_ID],
+        includeInterfaceView: true,
+        includeCreatedEventBlob: false,
+        activeAtOffset,
+    });
+    const allocations = new Map();
+    for (const [itemIndex, item] of response.entries()) {
+        if (!(0, contracts_1.isJsActiveContractItem)(item)) {
+            handleNonActiveContractItem(item, itemIndex, synchronizerId);
+            continue;
+        }
+        const activeContract = item.contractEntry.JsActiveContract;
+        if (activeContract.synchronizerId !== synchronizerId)
+            continue;
+        const { createdEvent } = activeContract;
+        if (!(0, utils_1.isNonEmptyString)(createdEvent.contractId) || !requestedCids.has(createdEvent.contractId))
+            continue;
+        for (const [viewIndex, interfaceView] of createdEvent.interfaceViews.entries()) {
+            if (!interfaceIdsMatch(interfaceView.interfaceId, exports.TOKEN_STANDARD_V2_ALLOCATION_INTERFACE_ID))
+                continue;
+            const context = {
+                itemIndex,
+                viewIndex,
+                contractId: createdEvent.contractId,
+                interfaceId: interfaceView.interfaceId,
+            };
+            if (interfaceView.viewStatus.code !== 0) {
+                interfaceViewInvalid('Token Standard V2 allocation interface view request failed.', {
+                    ...context,
+                    viewStatusCode: interfaceView.viewStatus.code,
+                    viewStatusMessage: interfaceView.viewStatus.message,
+                });
+            }
+            const identity = readAllocationViewIdentity(interfaceView.viewValue, context);
+            setConsistentState(allocations, createdEvent.contractId, {
+                type: 'Completed',
+                allocationCid: createdEvent.contractId,
+                view: readAllocationView(identity, context),
+            });
+        }
+    }
+    const missingAllocationCids = allocationCids.filter((contractId) => !allocations.has(contractId));
+    if (missingAllocationCids.length > 0) {
+        notFound('One or more requested Token Standard V2 allocations are not active and visible.', {
+            allocationCids,
+            missingAllocationCids,
+            synchronizerId,
+            activeAtOffset,
+        });
+    }
+    return allocationCids.map((allocationCid) => {
+        const allocation = allocations.get(allocationCid);
+        if (!allocation) {
+            notFound('A requested Token Standard V2 allocation disappeared while reading the ACS snapshot.', {
+                allocationCid,
+                activeAtOffset,
+            });
+        }
+        return { allocationCid, view: allocation.view };
+    });
+}
+/**
+ * Recovers the active Completed or Pending state for a Token Standard V2 allocation request.
+ *
+ * Unknown means only that no matching active contract is visible at the requested ACS snapshot. It must not be
+ * interpreted as Failed; recover Failed from the original transaction tree or command completion.
+ */
+async function discoverTokenStandardV2AllocationState(params) {
+    if (!(0, utils_1.isRecord)(params)) {
+        inputInvalid('params must be an allocation-state discovery request.', { field: 'params' });
+    }
+    if (!(0, utils_1.isRecord)(params.ledger) || typeof params.ledger.getActiveContracts !== 'function') {
+        inputInvalid('ledger must provide getActiveContracts.', { field: 'ledger' });
+    }
+    const parties = normalizeParties(params.parties);
+    const synchronizerId = requireTrimmedNonEmpty(params.synchronizerId, 'synchronizerId', inputInvalid);
+    const request = readRequest(params.request);
+    const activeAtOffset = normalizeActiveAtOffset(params.activeAtOffset);
+    const response = await params.ledger.getActiveContracts({
+        parties,
+        interfaceIds: [exports.TOKEN_STANDARD_V2_ALLOCATION_INTERFACE_ID, exports.TOKEN_STANDARD_V2_ALLOCATION_INSTRUCTION_INTERFACE_ID],
+        includeInterfaceView: true,
+        includeCreatedEventBlob: false,
+        activeAtOffset,
+    });
+    const completed = new Map();
+    const pending = new Map();
+    const allocationRows = new Map();
+    const instructionRows = new Map();
+    for (const [itemIndex, item] of response.entries()) {
+        if (!(0, contracts_1.isJsActiveContractItem)(item)) {
+            handleNonActiveContractItem(item, itemIndex, synchronizerId);
+            continue;
+        }
+        const activeContract = item.contractEntry.JsActiveContract;
+        if (activeContract.synchronizerId !== synchronizerId)
+            continue;
+        const { createdEvent } = activeContract;
+        for (const [viewIndex, interfaceView] of createdEvent.interfaceViews.entries()) {
+            const isAllocation = interfaceIdsMatch(interfaceView.interfaceId, exports.TOKEN_STANDARD_V2_ALLOCATION_INTERFACE_ID);
+            const isInstruction = interfaceIdsMatch(interfaceView.interfaceId, exports.TOKEN_STANDARD_V2_ALLOCATION_INSTRUCTION_INTERFACE_ID);
+            if (!isAllocation && !isInstruction)
+                continue;
+            const context = {
+                itemIndex,
+                viewIndex,
+                contractId: createdEvent.contractId,
+                interfaceId: interfaceView.interfaceId,
+            };
+            if (interfaceView.viewStatus.code !== 0) {
+                interfaceViewInvalid(`Token Standard V2 ${isAllocation ? 'allocation' : 'allocation instruction'} interface view request failed.`, {
+                    ...context,
+                    viewStatusCode: interfaceView.viewStatus.code,
+                    viewStatusMessage: interfaceView.viewStatus.message,
+                });
+            }
+            if (!(0, utils_1.isNonEmptyString)(createdEvent.contractId)) {
+                interfaceViewInvalid('Matching active contract is missing contractId.', context);
+            }
+            if (isAllocation) {
+                const identity = readAllocationViewIdentity(interfaceView.viewValue, context);
+                const state = {
+                    type: 'Completed',
+                    allocationCid: createdEvent.contractId,
+                    view: readAllocationView(identity, context),
+                };
+                setConsistentState(allocationRows, createdEvent.contractId, state);
+                if (allocationRequestCoreMatches(request, identity)) {
+                    setConsistentState(completed, createdEvent.contractId, state);
+                }
+            }
+            if (isInstruction) {
+                const identity = readAllocationInstructionViewIdentity(interfaceView.viewValue, context);
+                const state = {
+                    type: 'Pending',
+                    allocationInstructionCid: createdEvent.contractId,
+                    view: readAllocationInstructionView(identity, context),
+                };
+                setConsistentState(instructionRows, createdEvent.contractId, state);
+                if (allocationRequestCoreMatches(request, identity) &&
+                    timestampsEqual(request.requestedAt, identity.requestedAt) &&
+                    stringArraysEqual(request.inputHoldingCids, identity.inputHoldingCids)) {
+                    setConsistentState(pending, createdEvent.contractId, state);
+                }
+            }
+        }
+    }
+    if (completed.size > 1 || pending.size > 1 || (completed.size > 0 && pending.size > 0)) {
+        throw new TokenStandardV2AllocationStateError(exports.TokenStandardV2AllocationStateErrorCode.AMBIGUOUS, 'Multiple active contracts match the Token Standard V2 allocation request.', {
+            completedCids: [...completed.keys()].sort(),
+            pendingCids: [...pending.keys()].sort(),
+        });
+    }
+    const completedState = completed.values().next().value;
+    if (completedState)
+        return completedState;
+    const pendingState = pending.values().next().value;
+    if (pendingState)
+        return pendingState;
+    return { type: 'Unknown' };
+}
+//# sourceMappingURL=allocation-state.js.map