@rhinestone/sdk 2.5.0 → 2.7.0

package/dist/src/modules/validators/permissions.js

@@ -10,6 +10,88 @@ function isStaticAbiType(type) {
     }
     return false;
 }
+/** Split `T[k]` / `T[]` into element type and length (`''` when unbounded). */
+const ARRAY_SUFFIX = /^(.*)\[(\d*)\]$/;
+function withType(param, type) {
+    return { ...param, type };
+}
+function tupleComponents(param) {
+    return param.components ?? [];
+}
+/**
+ * True when the param is encoded as a 32-byte offset pointer in the head rather
+ * than inline. Mirrors the ABI spec: `bytes`, `string`, unbounded arrays, and
+ * any tuple/fixed-array transitively containing one of those.
+ */
+function isDynamicAbiParam(param) {
+    const { type } = param;
+    if (type === 'bytes' || type === 'string')
+        return true;
+    const array = ARRAY_SUFFIX.exec(type);
+    if (array) {
+        const [, elementType, length] = array;
+        if (length === '')
+            return true;
+        return isDynamicAbiParam(withType(param, elementType));
+    }
+    if (type === 'tuple')
+        return tupleComponents(param).some(isDynamicAbiParam);
+    return false;
+}
+/**
+ * Bytes this param occupies in the calldata HEAD.
+ *
+ * Not always 32: a static tuple is flattened inline (one word per leaf) and a
+ * fixed-size static array occupies `length` words. Computing offsets as
+ * `paramIndex * 32` silently mis-addresses every param that follows one of
+ * those — e.g. `f(uint256[3] a, address b)` would point at word 1 instead of
+ * word 3 and compare against array data, producing a policy that passes or
+ * fails for reasons unrelated to `b`.
+ */
+function headSize(param) {
+    if (isDynamicAbiParam(param))
+        return 32;
+    const array = ARRAY_SUFFIX.exec(param.type);
+    if (array) {
+        const [, elementType, length] = array;
+        return Number.parseInt(length, 10) * headSize(withType(param, elementType));
+    }
+    if (param.type === 'tuple') {
+        return tupleComponents(param).reduce((sum, c) => sum + headSize(c), 0);
+    }
+    return 32;
+}
+/** Byte offset of `inputs[index]` within the calldata head (past the selector). */
+function headOffset(inputs, index) {
+    let offset = 0;
+    for (let i = 0; i < index; i++)
+        offset += headSize(inputs[i]);
+    return BigInt(offset);
+}
+/**
+ * Calldata head offset of every named top-level parameter of `functionName`.
+ *
+ * Lets callers that build raw param rules (the swap venues) address arguments by
+ * name instead of hardcoding byte offsets — the offsets then follow the ABI
+ * automatically, and a signature change surfaces as a missing key rather than a
+ * rule silently pointing at the wrong word.
+ *
+ * Only single-word static params are included; anything dynamic or multi-word
+ * cannot be compared by a 32-byte reference value and is omitted.
+ */
+export function namedParamOffsets(abi, functionName) {
+    const entry = abi.find((item) => item.type === 'function' && item.name === functionName);
+    if (!entry) {
+        throw new Error(`Function "${functionName}" not found in ABI`);
+    }
+    const offsets = {};
+    entry.inputs.forEach((param, index) => {
+        if (param.name && isStaticAbiType(param.type)) {
+            offsets[param.name] = headOffset(entry.inputs, index);
+        }
+    });
+    return offsets;
+}
 function toReferenceValue(value, abiType) {
     if (abiType === 'address') {
         if (typeof value === 'string' && isAddress(value))
@@ -161,7 +243,22 @@ function resolvePermission(permission) {
                         'Permission rules only support static types ' +
                         '(address, bool, uint*, int*, bytes1–bytes32).');
                 }
-                const calldataOffset = BigInt(paramIndex) * 32n;
+                const calldataOffset = headOffset(abiEntry.inputs, paramIndex);
+                if (rule.min !== undefined || rule.max !== undefined) {
+                    if (rule.min === undefined || rule.max === undefined) {
+                        throw new Error(`Parameter "${paramName}" needs both "min" and "max" — ` +
+                            'provide the other bound, or use a single ' +
+                            '{ condition, value } comparison.');
+                    }
+                    return {
+                        paramName,
+                        calldataOffset,
+                        abiType: param.type,
+                        min: rule.min,
+                        max: rule.max,
+                        usageLimit: rule.usageLimit,
+                    };
+                }
                 if (rule.anyOf !== undefined) {
                     if (rule.anyOf.length === 0) {
                         throw new Error(`Parameter "${paramName}" has empty anyOf — provide at least one value.`);
@@ -182,7 +279,9 @@ function resolvePermission(permission) {
                     usageLimit: rule.usageLimit,
                 };
             });
-            const usesArgPolicy = normalized.some((n) => n.anyOf !== undefined);
+            // Both `anyOf` (OR chain) and `min`/`max` (AND of two rules on ONE param)
+            // need more than the flat one-rule-per-param shape UniActionPolicy offers.
+            const usesArgPolicy = normalized.some((n) => n.anyOf !== undefined || n.min !== undefined);
             // UniActionPolicy/ArgPolicy reject `msg.value > valueLimitPerUse`, so a
             // default of 0 would block any non-zero msg.value before the standalone
             // value-limit policy (sugar) could allow it. Inherit the sugar's cap so
@@ -203,6 +302,45 @@ function resolvePermission(permission) {
                         }));
                         return leaves.length === 1 ? leaves[0] : orChain(leaves);
                     }
+                    if (n.min !== undefined) {
+                        // Inclusive bounds as AND(x >= min, x <= max). Deliberately NOT the
+                        // policy's own `inRange` condition: that packs two uint128 bounds
+                        // into one bytes32 `ref`, which this SDK has no verified encoding
+                        // for. Two comparisons are exactly equivalent and use primitives
+                        // already covered by tests.
+                        //
+                        // `usageLimit` rides on the lower-bound leaf only — putting it on
+                        // both would double-count every call against the cumulative cap.
+                        const minRef = toReferenceValue(n.min, n.abiType);
+                        const maxRef = toReferenceValue(n.max, n.abiType);
+                        if (typeof minRef === 'bigint' &&
+                            typeof maxRef === 'bigint' &&
+                            minRef > maxRef) {
+                            throw new Error(`Parameter "${n.paramName}" has min (${minRef}) greater than ` +
+                                `max (${maxRef}) — no value can satisfy this rule.`);
+                        }
+                        return andChain([
+                            {
+                                type: 'rule',
+                                rule: {
+                                    condition: 'greaterThanOrEqual',
+                                    calldataOffset: n.calldataOffset,
+                                    referenceValue: minRef,
+                                    ...(n.usageLimit !== undefined
+                                        ? { usageLimit: n.usageLimit }
+                                        : {}),
+                                },
+                            },
+                            {
+                                type: 'rule',
+                                rule: {
+                                    condition: 'lessThanOrEqual',
+                                    calldataOffset: n.calldataOffset,
+                                    referenceValue: maxRef,
+                                },
+                            },
+                        ]);
+                    }
                     return {
                         type: 'rule',
                         rule: {

package/dist/src/modules/validators/quorum.d.ts

@@ -0,0 +1,66 @@
+import { type Address, type Hex } from 'viem';
+import type { ResolvedModule } from '../types.js';
+import type { AtomicValidatorDefinition, ValidatorContributionInput } from './types.js';
+/** Bind an ERC-1271 digest to its Quorum module, chain, and smart account. */
+export declare function getQuorumSignableHash(input: {
+    readonly validator: Address;
+    readonly chainId: number;
+    readonly account: Address;
+    readonly hash: Hex;
+}): Hex;
+export interface QuorumMerkleProof {
+    readonly root: Hex;
+    readonly proof: readonly Hex[];
+}
+export interface QuorumMerkleOperation extends QuorumMerkleProof {
+    readonly account: Address;
+    readonly digest: Hex;
+    readonly leaf: Hex;
+}
+/** Build account-bound leaves and Solady-compatible sorted-pair proofs. */
+export declare function buildQuorumMerkleTree(operations: readonly {
+    readonly account: Address;
+    readonly digest: Hex;
+}[]): {
+    readonly root: Hex;
+    readonly operations: readonly QuorumMerkleOperation[];
+};
+/** Hash the chain-agnostic EIP-712 root message signed by every owner. */
+export declare function getQuorumMerkleRootSignableHash(input: {
+    readonly validator: Address;
+    readonly root: Hex;
+}): Hex;
+/** Resolve Quorum Signer installation data from a weighted owner definition. */
+export declare function resolveQuorumValidator(definition: AtomicValidatorDefinition): ResolvedModule;
+/** Encode a regular Quorum Signer envelope from owner signature contributions. */
+export declare function encodeQuorumValidatorContribution(input: {
+    readonly owners: readonly {
+        readonly ownerId: string;
+        readonly signer: Address;
+        readonly weight: bigint;
+    }[];
+    readonly thresholdWeight: bigint;
+    readonly contributions: readonly Extract<ValidatorContributionInput, {
+        readonly kind: 'ecdsa';
+    }>[];
+}): Hex;
+/** Encode one Merkle proof with an already packed weighted quorum. */
+export declare function encodeQuorumMerkleEnvelope(input: {
+    readonly proof: QuorumMerkleProof;
+    readonly signatures: Hex;
+}): Hex;
+/** Encode weighted entries without the regular or Merkle envelope prefix. */
+export declare function encodeQuorumWeightedSignatures(input: {
+    readonly owners: readonly {
+        readonly ownerId: string;
+        readonly signer: Address;
+        readonly weight: bigint;
+    }[];
+    readonly thresholdWeight: bigint;
+    readonly contributions: readonly Extract<ValidatorContributionInput, {
+        readonly kind: 'ecdsa';
+    }>[];
+}): Hex;
+/** Build a structurally valid maximum-cost signature for bundler gas estimation. */
+export declare function encodeQuorumMockSignature(definition: AtomicValidatorDefinition): Hex;
+//# sourceMappingURL=quorum.d.ts.map

package/dist/src/modules/validators/quorum.d.ts.map

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

package/dist/src/modules/validators/quorum.js

@@ -0,0 +1,231 @@
+import { concat, encodeAbiParameters, hashTypedData, keccak256, size, toHex, } from 'viem';
+import { compareHexValues } from './ordering.js';
+const MAX_QUORUM_OWNERS = 32;
+const MAX_UINT96 = (1n << 96n) - 1n;
+const QUORUM_MESSAGE_TYPEHASH = keccak256(toHex('WeightedOwnableValidatorMessage(address validator,uint256 chainId,address account,bytes32 hash)'));
+/** Bind an ERC-1271 digest to its Quorum module, chain, and smart account. */
+export function getQuorumSignableHash(input) {
+    return keccak256(encodeAbiParameters([
+        { type: 'bytes32' },
+        { type: 'address' },
+        { type: 'uint256' },
+        { type: 'address' },
+        { type: 'bytes32' },
+    ], [
+        QUORUM_MESSAGE_TYPEHASH,
+        input.validator,
+        BigInt(input.chainId),
+        input.account,
+        input.hash,
+    ]));
+}
+/** Build account-bound leaves and Solady-compatible sorted-pair proofs. */
+export function buildQuorumMerkleTree(operations) {
+    if (operations.length < 2) {
+        throw new Error('Quorum Merkle signing requires at least two operations');
+    }
+    const leaves = operations.map(({ account, digest }) => keccak256(encodeAbiParameters([{ type: 'address' }, { type: 'bytes32' }], [account, digest])));
+    const layers = [leaves];
+    while (layers.at(-1).length > 1) {
+        const current = layers.at(-1);
+        const next = [];
+        for (let index = 0; index < current.length; index += 2) {
+            next.push(index + 1 < current.length
+                ? hashQuorumMerklePair(current[index], current[index + 1])
+                : current[index]);
+        }
+        layers.push(next);
+    }
+    const root = layers.at(-1)[0];
+    return {
+        root,
+        operations: operations.map(({ account, digest }, leafIndex) => {
+            const proof = [];
+            let index = leafIndex;
+            for (const layer of layers.slice(0, -1)) {
+                const siblingIndex = index % 2 === 0 ? index + 1 : index - 1;
+                if (siblingIndex < layer.length)
+                    proof.push(layer[siblingIndex]);
+                index = Math.floor(index / 2);
+            }
+            return { account, digest, leaf: leaves[leafIndex], root, proof };
+        }),
+    };
+}
+/** Hash the chain-agnostic EIP-712 root message signed by every owner. */
+export function getQuorumMerkleRootSignableHash(input) {
+    return hashTypedData({
+        domain: {
+            name: 'Quorum Signer',
+            version: '1',
+            verifyingContract: input.validator,
+        },
+        types: {
+            WeightedMerkleRoot: [{ name: 'root', type: 'bytes32' }],
+        },
+        primaryType: 'WeightedMerkleRoot',
+        message: { root: input.root },
+    });
+}
+function hashQuorumMerklePair(left, right) {
+    return compareHexValues(left, right) < 0
+        ? keccak256(concat([left, right]))
+        : keccak256(concat([right, left]));
+}
+const MAX_SIGNATURE_LENGTH = 65_535;
+const QUORUM_MOCK_SIGNATURE = `0x${'00'.repeat(64)}1b`;
+/** Resolve Quorum Signer installation data from a weighted owner definition. */
+export function resolveQuorumValidator(definition) {
+    if (definition.kind !== 'quorum') {
+        throw new Error('Quorum resolver received a non-quorum validator');
+    }
+    const owners = resolveOwners(definition).sort((left, right) => compareHexValues(left.signer, right.signer));
+    const thresholdWeight = requireThresholdWeight(definition);
+    validateQuorumConfig(owners, thresholdWeight);
+    if (definition.module.source !== 'explicit') {
+        throw new Error('Quorum validator requires a deployed module address');
+    }
+    return {
+        kind: 'validator',
+        address: definition.module.address,
+        initData: encodeAbiParameters([
+            { name: 'thresholdWeight', type: 'uint256' },
+            {
+                name: 'owners',
+                type: 'tuple[]',
+                components: [
+                    { name: 'addr', type: 'address' },
+                    { name: 'weight', type: 'uint96' },
+                ],
+            },
+        ], [
+            thresholdWeight,
+            owners.map(({ signer, weight }) => ({ addr: signer, weight })),
+        ]),
+        deInitData: '0x',
+        additionalContext: '0x',
+    };
+}
+/** Encode a regular Quorum Signer envelope from owner signature contributions. */
+export function encodeQuorumValidatorContribution(input) {
+    return concat(['0x00', encodeSelectedQuorumSignatures(input)]);
+}
+function encodeSelectedQuorumSignatures(input) {
+    validateQuorumConfig(input.owners, input.thresholdWeight);
+    const configured = new Map(input.owners.map((owner) => [owner.ownerId, owner]));
+    const contributions = new Map();
+    for (const contribution of input.contributions) {
+        if (!configured.has(contribution.ownerId)) {
+            throw new Error(`Unknown validator owner ${contribution.ownerId}`);
+        }
+        if (contributions.has(contribution.ownerId)) {
+            throw new Error(`Duplicate validator owner ${contribution.ownerId}`);
+        }
+        contributions.set(contribution.ownerId, contribution.signature);
+    }
+    const selected = input.owners
+        .filter((owner) => contributions.has(owner.ownerId))
+        .sort((left, right) => compareAddresses(left.signer, right.signer));
+    const signedWeight = selected.reduce((sum, owner) => sum + owner.weight, 0n);
+    if (signedWeight < input.thresholdWeight) {
+        throw new Error(`Insufficient validator contribution weight: required ${input.thresholdWeight}, received ${signedWeight}`);
+    }
+    return encodeQuorumEntries(selected.map((owner) => ({
+        signer: owner.signer,
+        signature: contributions.get(owner.ownerId),
+    })));
+}
+/** Encode one Merkle proof with an already packed weighted quorum. */
+export function encodeQuorumMerkleEnvelope(input) {
+    if (input.proof.proof.length < 1 || input.proof.proof.length > 32) {
+        throw new Error('Quorum Merkle proof length must be between 1 and 32');
+    }
+    if (input.signatures === '0x') {
+        throw new Error('Quorum Merkle signatures must not be empty');
+    }
+    return concat([
+        toHex(input.proof.proof.length, { size: 1 }),
+        input.proof.root,
+        ...input.proof.proof,
+        input.signatures,
+    ]);
+}
+/** Encode weighted entries without the regular or Merkle envelope prefix. */
+export function encodeQuorumWeightedSignatures(input) {
+    return encodeSelectedQuorumSignatures(input);
+}
+/** Build a structurally valid maximum-cost signature for bundler gas estimation. */
+export function encodeQuorumMockSignature(definition) {
+    if (definition.kind !== 'quorum') {
+        throw new Error('Quorum mock signature requires a quorum validator');
+    }
+    const owners = resolveOwners(definition);
+    validateQuorumConfig(owners, requireThresholdWeight(definition));
+    return concat([
+        '0x00',
+        encodeQuorumEntries(owners
+            .map(({ signer }) => ({ signer, signature: QUORUM_MOCK_SIGNATURE }))
+            .sort((left, right) => compareAddresses(left.signer, right.signer))),
+    ]);
+}
+function encodeQuorumEntries(entries) {
+    if (entries.length === 0)
+        throw new Error('Quorum signature must not be empty');
+    let previous;
+    const packed = entries.map(({ signer, signature }) => {
+        if (previous && compareAddresses(previous, signer) >= 0) {
+            throw new Error('Quorum signer addresses must be strictly sorted and unique');
+        }
+        previous = signer;
+        const signatureLength = size(signature);
+        if (signatureLength > MAX_SIGNATURE_LENGTH) {
+            throw new Error(`Quorum inner signature exceeds ${MAX_SIGNATURE_LENGTH} bytes`);
+        }
+        return concat([signer, toHex(signatureLength, { size: 2 }), signature]);
+    });
+    return concat(packed);
+}
+function resolveOwners(definition) {
+    return definition.owners.map((owner) => {
+        if (owner.kind === 'webauthn' || owner.weight === undefined) {
+            throw new Error('Quorum validator requires weighted ECDSA owners');
+        }
+        return {
+            ownerId: owner.id,
+            signer: owner.account.address,
+            weight: owner.weight,
+        };
+    });
+}
+function requireThresholdWeight(definition) {
+    if (definition.thresholdWeight === undefined) {
+        throw new Error('Quorum validator threshold weight is missing');
+    }
+    return definition.thresholdWeight;
+}
+function validateQuorumConfig(owners, thresholdWeight) {
+    if (owners.length < 1 || owners.length > MAX_QUORUM_OWNERS) {
+        throw new Error(`Quorum owners length must be between 1 and ${MAX_QUORUM_OWNERS}`);
+    }
+    const seen = new Set();
+    let totalWeight = 0n;
+    for (const [index, owner] of owners.entries()) {
+        const signer = owner.signer.toLowerCase();
+        if (signer === '0x0000000000000000000000000000000000000000') {
+            throw new Error(`Quorum owner ${index} cannot be the zero address`);
+        }
+        if (seen.has(signer))
+            throw new Error(`Duplicate quorum owner ${owner.signer}`);
+        seen.add(signer);
+        if (owner.weight <= 0n || owner.weight > MAX_UINT96) {
+            throw new Error(`Quorum owner ${owner.signer} weight must fit uint96 and be non-zero`);
+        }
+        totalWeight += owner.weight;
+    }
+    if (thresholdWeight <= 0n || thresholdWeight > totalWeight) {
+        throw new Error(`Quorum threshold weight must be between 1 and total owner weight ${totalWeight}`);
+    }
+}
+function compareAddresses(left, right) {
+    return compareHexValues(left, right);
+}

package/dist/src/modules/validators/resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../modules/validators/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAI9C,OAAO,KAAK,EACV,yBAAyB,EACzB,2BAA2B,EAC5B,MAAM,SAAS,CAAA;AAChB,OAAO,EAGL,KAAK,0BAA0B,EAChC,MAAM,YAAY,CAAA;AAEnB,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,yBAAyB,EACrC,gBAAgB,CAAC,EAAE,0BAA0B,GAC5C,cAAc,CAYhB;AAKD,wBAAgB,mCAAmC,CACjD,UAAU,EAAE,yBAAyB,GACpC,GAAG,CAYL;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,yBAAyB;;;EAMtC;AAKD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,2BAA2B,EACvC,gBAAgB,CAAC,EAAE,0BAA0B,GAC5C,cAAc,CAIhB"}
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../modules/validators/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAK9C,OAAO,KAAK,EACV,yBAAyB,EACzB,2BAA2B,EAC5B,MAAM,SAAS,CAAA;AAChB,OAAO,EAGL,KAAK,0BAA0B,EAChC,MAAM,YAAY,CAAA;AAEnB,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,yBAAyB,EACrC,gBAAgB,CAAC,EAAE,0BAA0B,GAC5C,cAAc,CAchB;AAKD,wBAAgB,mCAAmC,CACjD,UAAU,EAAE,yBAAyB,GACpC,GAAG,CAgBL;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,yBAAyB;;;EAMtC;AAKD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,2BAA2B,EACvC,gBAAgB,CAAC,EAAE,0BAA0B,GAC5C,cAAc,CAIhB"}

package/dist/src/modules/validators/resolve.js

@@ -1,11 +1,14 @@
 import { encodeEnsStatelessData, resolveEnsValidator } from './ens.js';
 import { resolveMultiFactorValidator } from './multi-factor.js';
 import { resolveOwnableStatelessData, resolveOwnableValidator } from './ownable.js';
+import { resolveQuorumValidator } from './quorum.js';
 import { resolveWebauthnStatelessData, resolveWebauthnValidator, } from './webauthn.js';
 export function resolveAtomicValidator(definition, webauthnOrdering) {
     switch (definition.kind) {
         case 'ecdsa':
             return resolveOwnableValidator(definition);
+        case 'quorum':
+            return resolveQuorumValidator(definition);
         case 'ens':
             return resolveEnsValidator(definition);
         case 'passkey':
@@ -26,6 +29,8 @@ export function resolveAtomicValidatorStatelessData(definition) {
             return encodeEnsStatelessData(definition);
         case 'passkey':
             return resolveWebauthnStatelessData(definition);
+        case 'quorum':
+            throw new Error('Validator quorum cannot be used as a multi-factor factor');
         case 'k1':
         case 'smart-session':
             throw new Error(`Validator ${definition.kind} requires feature input`);

package/dist/src/modules/validators/smart-sessions/resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../../modules/validators/smart-sessions/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,GAAG,EAAgC,MAAM,MAAM,CAAA;AAU3E,OAAO,EACL,wBAAwB,EAEzB,MAAM,sBAAsB,CAAA;AAO7B,OAAO,KAAK,EAEV,OAAO,EAEP,WAAW,EACX,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,mCAAmC,EAAE,OACJ,CAAA;AAC9C,eAAO,MAAM,4CAA4C,EAAE,GAAkB,CAAA;AAC7E,eAAO,MAAM,2EAA2E,EACtF,YAAqB,CAAA;AACvB,eAAO,MAAM,uBAAuB,EAClC,4CAAqD,CAAA;AACvD,eAAO,MAAM,yBAAyB,EAAG,YAAqB,CAAA;AAU9D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,YAAY,GAAG,aAAa,CAAA;IAGnD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CACtC;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,iBAAiB,EAC7B,OAAO,GAAE,qBAA0B,GAClC,WAAW,CA0Fb;AAED,wBAAgB,SAAS,CACvB,UAAU,EAAE,iBAAiB,EAC7B,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAyBT;AAED,OAAO,EAAE,wBAAwB,EAAE,CAAA"}
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../../modules/validators/smart-sessions/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,GAAG,EAAgC,MAAM,MAAM,CAAA;AAU3E,OAAO,EACL,wBAAwB,EAEzB,MAAM,sBAAsB,CAAA;AAQ7B,OAAO,KAAK,EAGV,OAAO,EAEP,WAAW,EACX,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,mCAAmC,EAAE,OACJ,CAAA;AAC9C,eAAO,MAAM,4CAA4C,EAAE,GAAkB,CAAA;AAC7E,eAAO,MAAM,2EAA2E,EACtF,YAAqB,CAAA;AACvB,eAAO,MAAM,uBAAuB,EAClC,4CAAqD,CAAA;AACvD,eAAO,MAAM,yBAAyB,EAAG,YAAqB,CAAA;AAU9D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,YAAY,GAAG,aAAa,CAAA;IAGnD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CACtC;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,iBAAiB,EAC7B,OAAO,GAAE,qBAA0B,GAClC,WAAW,CAqMb;AAED,wBAAgB,SAAS,CACvB,UAAU,EAAE,iBAAiB,EAC7B,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAoCT;AAED,OAAO,EAAE,wBAAwB,EAAE,CAAA"}