@rhinestone/sdk 2.0.0-beta.8 → 2.0.0

package/dist/src/signing/intent-plans/independent.js

@@ -0,0 +1,150 @@
+import { InsufficientOwnerSignaturesError, MismatchedOwnerSignaturesError, UnknownOwnerError, } from '../../errors/execution.js';
+import { encodeValidatorContribution } from '../../modules/validators/contribution.js';
+import { encodeValidatorId } from '../../modules/validators/multi-factor.js';
+import { assembleIntentValidatorArtifact } from './assemble.js';
+export function assembleIndependentIntentArtifact(input) {
+    if (input.artifact.validatorCodec.kind === 'none') {
+        throw new Error('Independent signing requires a validator codec');
+    }
+    if (input.artifact.validatorCodec.kind === 'smart-session-state') {
+        throw new Error('Smart Session state cannot be signed independently');
+    }
+    const contributions = importOwnerContributions(input);
+    const codec = input.artifact.validatorCodec;
+    if (codec.kind === 'smart-session') {
+        throw new Error('Smart Session state cannot be signed independently');
+    }
+    const validatorContribution = input.artifact.validatorFactors
+        ? encodeIndependentFactors(codec, input.artifact.validatorFactors, contributions)
+        : encodeAtomicContributions(codec, contributions.map(({ contribution }) => contribution));
+    return assembleIntentValidatorArtifact({
+        artifact: input.artifact,
+        context: input.context,
+        validatorContribution,
+    });
+}
+function importOwnerContributions(input) {
+    const seen = new Set();
+    return input.signatures.map((value) => {
+        if (value.intentId !== input.intentId) {
+            throw new MismatchedOwnerSignaturesError({
+                context: { intentIds: [input.intentId, value.intentId] },
+            });
+        }
+        const signature = value.kind === 'multi-factor' ? value.signature : value;
+        if (signature.origin.length !== input.originCount) {
+            throw new MismatchedOwnerSignaturesError({
+                context: { expectedOriginCount: input.originCount },
+            });
+        }
+        const identity = signature.kind === 'ecdsa'
+            ? signature.signer.toLowerCase()
+            : signature.publicKey.toLowerCase();
+        const owner = input.owners.find((candidate) => candidate.identity.toLowerCase() === identity &&
+            (value.kind === 'multi-factor'
+                ? candidate.factorPublicId !== undefined &&
+                    sameValidatorId(candidate.factorPublicId, value.validatorId)
+                : candidate.factorId === undefined));
+        if (!owner) {
+            const matchingIdentity = input.owners.filter((candidate) => candidate.identity.toLowerCase() === identity);
+            if (matchingIdentity.length > 0 &&
+                (value.kind === 'multi-factor' ||
+                    matchingIdentity.some(({ factorId }) => factorId !== undefined))) {
+                throw new MismatchedOwnerSignaturesError({
+                    context: value.kind === 'multi-factor'
+                        ? { validatorId: value.validatorId }
+                        : { expectedKind: 'multi-factor' },
+                });
+            }
+            throw new UnknownOwnerError({
+                context: signature.kind === 'passkey'
+                    ? { publicKey: signature.publicKey }
+                    : { signer: signature.signer },
+            });
+        }
+        const contributionKey = `${owner.factorId ?? 'root'}:${identity}`;
+        if (seen.has(contributionKey))
+            throw new MismatchedOwnerSignaturesError({
+                context: { duplicateOwner: identity },
+            });
+        seen.add(contributionKey);
+        if ((signature.kind === 'ecdsa' && owner.kind !== 'ecdsa') ||
+            (signature.kind === 'passkey' && owner.kind !== 'webauthn')) {
+            throw new MismatchedOwnerSignaturesError({
+                context: { owner: identity },
+            });
+        }
+        const contribution = signature.kind === 'ecdsa'
+            ? {
+                kind: 'ecdsa',
+                ownerId: owner.ownerId,
+                signature: signature.origin[input.originIndex],
+                encoding: 'validator-contribution',
+            }
+            : {
+                kind: 'webauthn',
+                ownerId: owner.ownerId,
+                publicKey: signature.publicKey,
+                signature: signature.origin[input.originIndex].signature,
+                authenticatorData: signature.origin[input.originIndex].webauthn.authenticatorData,
+                clientDataJSON: signature.origin[input.originIndex].webauthn.clientDataJSON,
+                challengeIndex: signature.origin[input.originIndex].webauthn.challengeIndex ?? 0,
+                typeIndex: signature.origin[input.originIndex].webauthn.typeIndex ?? 0,
+                userVerificationRequired: signature.origin[input.originIndex].webauthn
+                    .userVerificationRequired ?? false,
+            };
+        return {
+            ...(owner.factorId ? { factorId: owner.factorId } : {}),
+            contribution,
+        };
+    });
+}
+function sameValidatorId(left, right) {
+    try {
+        return (encodeValidatorId(left).toLowerCase() ===
+            encodeValidatorId(right).toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
+function encodeIndependentFactors(codec, factors, contributions) {
+    const factorContributions = factors.flatMap((factor) => {
+        const selected = contributions.flatMap((entry) => entry.factorId === factor.id ? [entry.contribution] : []);
+        if (selected.length === 0)
+            return [];
+        if (selected.length < factor.codec.threshold) {
+            throw new InsufficientOwnerSignaturesError({
+                required: factor.codec.threshold,
+                provided: selected.length,
+                validatorId: factor.publicId,
+            });
+        }
+        return [
+            {
+                kind: 'factor',
+                factorId: factor.id,
+                publicId: factor.publicId,
+                validator: factor.validator,
+                contribution: encodeValidatorContribution(factor.codec, selected),
+            },
+        ];
+    });
+    if (factorContributions.length < codec.threshold) {
+        throw new InsufficientOwnerSignaturesError({
+            required: codec.threshold,
+            provided: factorContributions.length,
+        });
+    }
+    return encodeValidatorContribution(codec, factorContributions);
+}
+function encodeAtomicContributions(codec, contributions) {
+    if (codec.kind === 'ordered-threshold' &&
+        contributions.length < codec.threshold) {
+        throw new InsufficientOwnerSignaturesError({
+            required: codec.threshold,
+            provided: contributions.length,
+        });
+    }
+    return encodeValidatorContribution(codec, contributions);
+}

package/dist/src/signing/intent-plans/plan.d.ts

@@ -0,0 +1,14 @@
+import type { SigningContext } from '../context.js';
+import type { SigningCheckpointPort, SigningPlan, SigningTranscript } from '../types.js';
+import type { IndependentSigningProjection, IntentSigningPlanCreationInput } from './types.js';
+export declare function createIntentSigningPlan(input: IntentSigningPlanCreationInput): SigningPlan;
+export declare function projectIndependentSigning(plan: SigningPlan, signerIds: readonly string[], ownerIds?: readonly string[]): {
+    readonly plan: SigningPlan;
+    readonly projection: IndependentSigningProjection;
+};
+export declare function executeIntentSigning(input: {
+    readonly planInput: IntentSigningPlanCreationInput;
+    readonly context: SigningContext;
+    readonly checkpoints: SigningCheckpointPort;
+}): Promise<SigningTranscript>;
+//# sourceMappingURL=plan.d.ts.map

package/dist/src/signing/intent-plans/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../../signing/intent-plans/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD,OAAO,KAAK,EACV,qBAAqB,EACrB,WAAW,EACX,iBAAiB,EAClB,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EACV,4BAA4B,EAC5B,8BAA8B,EAC/B,MAAM,SAAS,CAAA;AAEhB,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,8BAA8B,GACpC,WAAW,CAoEb;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,GAC3B;IACD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,4BAA4B,CAAA;CAClD,CA8DA;AAoFD,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,SAAS,EAAE,8BAA8B,CAAA;IAClD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAA;CAC5C,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAS7B"}

package/dist/src/signing/intent-plans/plan.js

@@ -0,0 +1,187 @@
+import { executeSigningPlan } from '../execute.js';
+import { assembleIntentStage } from './assemble.js';
+export function createIntentSigningPlan(input) {
+    const targetArtifact = input.intent.target
+        ? requireSingleArtifact(input.intent.artifacts.filter(({ usage, payloadId }) => usage === 'intent-target' && payloadId === input.intent.target?.id), 'target')
+        : undefined;
+    const plan = {
+        version: 1,
+        kind: 'intent-full',
+        payload: { kind: 'intent', id: input.intent.id },
+        configuredTopology: input.intent.configuredTopology,
+        effectiveSelection: input.intent.effectiveSelection,
+        preparedIntent: {
+            signatureMode: input.intent.preparedSignatureMode,
+            artifacts: input.intent.artifacts.map(({ id, usage, payloadId, cardinality, shape }) => ({
+                id,
+                usage,
+                payloadId,
+                cardinality,
+                shape,
+            })),
+            ...(input.intent.destination
+                ? {
+                    destination: input.intent.destination.mode === 'sign'
+                        ? {
+                            mode: 'sign',
+                            artifactId: input.intent.destination.artifactId,
+                            payloadId: input.intent.destination.payload.id,
+                        }
+                        : input.intent.destination,
+                }
+                : {}),
+            ...(targetArtifact
+                ? {
+                    target: {
+                        artifactId: targetArtifact.id,
+                        payloadId: targetArtifact.payloadId,
+                    },
+                }
+                : {}),
+        },
+        stages: input.stages.map((stage) => ({
+            id: stage.id,
+            checkpoint: stage.checkpoint,
+            priorOutputs: stage.priorOutputs,
+            taskTemplates: stage.tasks,
+            schedule: stage.schedule,
+            artifacts: stage.artifacts.map((artifact) => ({
+                ...artifact,
+                stageId: stage.id,
+            })),
+        })),
+        publicOutputs: input.intent.artifacts.map((artifact) => ({
+            id: artifact.id,
+            source: { kind: 'artifact', artifactId: artifact.id },
+            exposedForIndependentSigning: artifact.exposedForIndependentSigning,
+        })),
+    };
+    assertPreparedMode(input);
+    assertIntentRoutes(input, plan);
+    return plan;
+}
+export function projectIndependentSigning(plan, signerIds, ownerIds) {
+    if (plan.kind !== 'intent-full') {
+        throw new Error('Independent signing requires a full intent plan');
+    }
+    const selected = new Set(signerIds);
+    const selectedOwners = ownerIds ? new Set(ownerIds) : undefined;
+    if (selected.size !== signerIds.length) {
+        throw new Error('Independent signer selection contains duplicates');
+    }
+    for (const signerId of selected) {
+        if (!plan.effectiveSelection.signerIds.includes(signerId)) {
+            throw new Error(`Independent signer ${signerId} is not in the plan`);
+        }
+    }
+    const stages = plan.stages.map((stage) => {
+        const taskTemplates = stage.taskTemplates.filter((task) => selected.has(task.signer.id) &&
+            (!selectedOwners ||
+                [...selectedOwners].some((ownerId) => task.id.includes(ownerId))));
+        const taskIds = new Set(taskTemplates.map(({ id }) => id));
+        return {
+            ...stage,
+            priorOutputs: [],
+            taskTemplates,
+            schedule: stage.schedule
+                .map((batch) => ({
+                ...batch,
+                taskIds: batch.taskIds.filter((taskId) => taskIds.has(taskId)),
+            }))
+                .filter(({ taskIds: ids }) => ids.length > 0),
+            artifacts: [],
+        };
+    });
+    const projected = {
+        ...plan,
+        kind: 'intent-independent',
+        effectiveSelection: {
+            ...plan.effectiveSelection,
+            signerIds: plan.effectiveSelection.signerIds.filter((id) => selected.has(id)),
+        },
+        stages,
+        publicOutputs: stages.flatMap((stage) => stage.taskTemplates.map((task) => ({
+            id: `${task.id}-contribution`,
+            source: { kind: 'task-result', taskId: task.id },
+            exposedForIndependentSigning: true,
+        }))),
+    };
+    return {
+        plan: projected,
+        projection: {
+            planKind: 'intent-independent',
+            sourceIntentId: plan.payload.id,
+            exposedArtifactIds: projected.publicOutputs.map(({ id }) => id),
+            selectedSignerIds: [...signerIds],
+        },
+    };
+}
+function assertIntentRoutes(input, plan) {
+    const artifacts = plan.stages.flatMap((stage) => stage.artifacts);
+    const requirements = new Map(input.intent.artifacts.map((artifact) => [artifact.id, artifact]));
+    if (requirements.size !== input.intent.artifacts.length) {
+        throw new Error('Intent artifact requirements contain duplicate ids');
+    }
+    for (const requirement of input.intent.artifacts) {
+        if (!artifacts.some(({ id }) => id === requirement.id)) {
+            throw new Error(`Intent artifact ${requirement.id} has no assembly route`);
+        }
+    }
+    const destination = input.intent.destination;
+    if (!destination)
+        return;
+    const requirement = requirements.get(destination.artifactId);
+    if (!requirement || requirement.usage !== 'intent-destination') {
+        throw new Error('Intent destination artifact requirement is missing');
+    }
+    const route = artifacts.find(({ id }) => id === destination.artifactId);
+    if (!route)
+        throw new Error('Intent destination assembly route is missing');
+    if (destination.mode === 'sign') {
+        if (requirement.payloadId !== destination.payload.id ||
+            route.input.kind !== 'task-results') {
+            throw new Error('Intent destination signing route is incompatible');
+        }
+        return;
+    }
+    if (route.input.kind !== 'reuse-artifact' ||
+        route.input.artifactId !== destination.originArtifactId ||
+        route.input.selection !== destination.selection) {
+        throw new Error('Intent destination reuse route is incompatible');
+    }
+}
+function requireSingleArtifact(artifacts, role) {
+    if (artifacts.length !== 1) {
+        throw new Error(`Intent ${role} requires exactly one artifact`);
+    }
+    return artifacts[0];
+}
+function assertPreparedMode(input) {
+    const originArtifacts = input.intent.artifacts.filter(({ usage }) => usage === 'intent-origin' ||
+        usage === 'intent-pre-claim' ||
+        usage === 'intent-notarized-claim');
+    const expectedPerOrigin = 1;
+    const expected = input.intent.origins.length * expectedPerOrigin;
+    if (originArtifacts.length !== expected) {
+        throw new Error(`Prepared signature mode requires ${expected} origin artifacts, received ${originArtifacts.length}`);
+    }
+    const invalidShape = originArtifacts.some(({ shape }) => input.intent.preparedSignatureMode === 'default'
+        ? shape !== 'hex'
+        : !['hex', 'session-claims'].includes(shape));
+    if (invalidShape) {
+        const expectedShape = input.intent.preparedSignatureMode === 'default'
+            ? 'hex'
+            : 'hex or session-claims';
+        throw new Error(`Prepared signature mode requires ${expectedShape} origin artifacts`);
+    }
+}
+export async function executeIntentSigning(input) {
+    const plan = createIntentSigningPlan(input.planInput);
+    return executeSigningPlan({
+        plan,
+        payloads: input.planInput.payloads,
+        signerInvoker: input.context.signerInvoker,
+        checkpoints: input.checkpoints,
+        assembleStage: (stage) => assembleIntentStage(stage, input.context),
+    });
+}

package/dist/src/signing/intent-plans/types.d.ts

@@ -0,0 +1,63 @@
+import type { Hex, TypedDataDefinition } from 'viem';
+import type { EvmChainReference } from '../../chains/types.js';
+import type { ArtifactAssemblyPlan, ConfiguredValidatorTopology, EffectiveSignerSelection, SignatureUsage, SigningBatch, SigningPayloadRegistry, SigningReadCheckpoint, SigningTaskTemplate } from '../types.js';
+export type PreparedIntentSignatureMode = 'default' | 'session' | 'session-with-execution-verification';
+export interface IntentSigningPayload {
+    readonly id: Hex;
+    readonly chain: EvmChainReference;
+    readonly role: 'origin' | 'destination' | 'target';
+    readonly typedData: TypedDataDefinition;
+    readonly usage: SignatureUsage;
+}
+export type DestinationSigningRequirement = {
+    readonly mode: 'sign';
+    readonly payload: IntentSigningPayload;
+    readonly artifactId: string;
+} | {
+    readonly mode: 'reuse-origin';
+    readonly artifactId: string;
+    readonly originArtifactId: string;
+    readonly selection: 'whole' | 'pre-claim';
+};
+export interface IntentArtifactRequirement {
+    readonly id: string;
+    readonly usage: SignatureUsage;
+    readonly payloadId: Hex;
+    readonly cardinality: 'one' | 'per-origin';
+    readonly shape: 'hex' | 'session-claims';
+    readonly exposedForIndependentSigning: boolean;
+}
+export interface IntentSigningInput {
+    readonly id: Hex;
+    readonly preparedSignatureMode: PreparedIntentSignatureMode;
+    readonly configuredTopology: ConfiguredValidatorTopology;
+    readonly effectiveSelection: EffectiveSignerSelection;
+    readonly origins: readonly IntentSigningPayload[];
+    readonly destination?: DestinationSigningRequirement;
+    readonly target?: IntentSigningPayload;
+    readonly artifacts: readonly IntentArtifactRequirement[];
+}
+export interface IndependentSigningProjection {
+    readonly planKind: 'intent-independent';
+    readonly sourceIntentId: Hex;
+    readonly exposedArtifactIds: readonly string[];
+    readonly selectedSignerIds: readonly string[];
+}
+export interface IntentSigningStageInput {
+    readonly id: string;
+    readonly checkpoint: SigningReadCheckpoint;
+    readonly priorOutputs: readonly {
+        readonly stageId: string;
+        readonly outputId: string;
+        readonly selection: 'whole' | 'pre-claim';
+    }[];
+    readonly tasks: readonly SigningTaskTemplate[];
+    readonly schedule: readonly SigningBatch[];
+    readonly artifacts: readonly Omit<ArtifactAssemblyPlan, 'stageId'>[];
+}
+export interface IntentSigningPlanCreationInput {
+    readonly intent: IntentSigningInput;
+    readonly stages: readonly IntentSigningStageInput[];
+    readonly payloads: SigningPayloadRegistry;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/signing/intent-plans/types.d.ts.map

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

package/dist/src/signing/intent-plans/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/signing/message.d.ts

@@ -0,0 +1,28 @@
+import { type Hex, type SignableMessage } from 'viem';
+import type { EvmChainReference } from '../chains/types.js';
+import type { SigningContext } from './context.js';
+import type { ArtifactAssemblyPlan, ConfiguredValidatorTopology, EffectiveSignerSelection, PayloadSigningTask, SigningCheckpointPort, SigningPayloadMaterial, SigningPlan, SigningTranscript } from './types.js';
+export interface MessageSigningPlanInput {
+    readonly message: SignableMessage;
+    readonly signingMaterial?: Extract<SigningPayloadMaterial, {
+        readonly kind: 'message';
+    }>;
+    readonly chain: EvmChainReference;
+    readonly configuredTopology: ConfiguredValidatorTopology;
+    readonly effectiveSelection: EffectiveSignerSelection;
+    readonly tasks: readonly PayloadSigningTask[];
+    readonly route: Omit<ArtifactAssemblyPlan, 'id' | 'stageId' | 'input' | 'usage'>;
+    readonly checkpoint?: Extract<import('./types.js').SigningReadCheckpoint, {
+        readonly kind: 'account-deployment';
+    }>;
+}
+export declare function createMessageSigningPlan(input: MessageSigningPlanInput): SigningPlan;
+export declare function signAccountMessage(input: {
+    readonly planInput: MessageSigningPlanInput;
+    readonly context: SigningContext;
+    readonly checkpoints: SigningCheckpointPort;
+}): Promise<{
+    readonly signature: Hex;
+    readonly transcript: SigningTranscript;
+}>;
+//# sourceMappingURL=message.d.ts.map

package/dist/src/signing/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../../signing/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAe,KAAK,eAAe,EAAE,MAAM,MAAM,CAAA;AAElE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAM/C,OAAO,KAAK,EACV,oBAAoB,EACpB,2BAA2B,EAC3B,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACX,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAChC,sBAAsB,EACtB;QAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;KAAE,CAC7B,CAAA;IACD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,kBAAkB,EAAE,2BAA2B,CAAA;IACxD,QAAQ,CAAC,kBAAkB,EAAE,wBAAwB,CAAA;IACrD,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAC7C,QAAQ,CAAC,KAAK,EAAE,IAAI,CAClB,oBAAoB,EACpB,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CACrC,CAAA;IACD,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAC3B,OAAO,SAAS,EAAE,qBAAqB,EACvC;QAAE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAA;KAAE,CACxC,CAAA;CACF;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,uBAAuB,GAC7B,WAAW,CAkBb;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE;IAC9C,QAAQ,CAAC,SAAS,EAAE,uBAAuB,CAAA;IAC3C,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAA;CAC5C,GAAG,OAAO,CAAC;IACV,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;CACvC,CAAC,CAqBD"}

package/dist/src/signing/message.js

@@ -0,0 +1,90 @@
+import { hashMessage } from 'viem';
+import { EoaSigningNotSupportedError } from '../accounts/error.js';
+import { encodePlannedValidatorContribution } from './contribution.js';
+import { runSigningStep } from './error.js';
+import { executeSigningPlan } from './execute.js';
+import { createSingleStageSigningPlan } from './plan.js';
+import { wrapErc6492Signature } from './protocols/erc6492.js';
+export function createMessageSigningPlan(input) {
+    return createSingleStageSigningPlan({
+        kind: 'account-message',
+        payload: { kind: 'message', id: hashMessage(input.message) },
+        configuredTopology: input.configuredTopology,
+        effectiveSelection: input.effectiveSelection,
+        stageId: 'message',
+        ...(input.checkpoint ? { checkpoint: input.checkpoint } : {}),
+        chain: input.chain,
+        tasks: input.tasks,
+        artifacts: [
+            {
+                id: 'message-signature',
+                usage: 'erc1271',
+                ...input.route,
+            },
+        ],
+    });
+}
+export async function signAccountMessage(input) {
+    if (input.context.account.definition.kind === 'eoa') {
+        throw new EoaSigningNotSupportedError('packed signatures');
+    }
+    const plan = createMessageSigningPlan(input.planInput);
+    const transcript = await executeSigningPlan({
+        plan,
+        payloads: {
+            [plan.payload.id]: {
+                kind: 'message',
+                message: input.planInput.signingMaterial?.message ??
+                    { raw: plan.payload.id },
+            },
+        },
+        checkpoints: input.checkpoints,
+        signerInvoker: input.context.signerInvoker,
+        assembleStage: (stage) => assembleMessageStage(stage, input.context),
+    });
+    const signature = transcript.stages[0].outputs['message-signature'];
+    return { signature, transcript };
+}
+function assembleMessageStage(input, context) {
+    const artifact = input.stagePlan.artifacts[0];
+    if (!artifact)
+        throw new Error('Message plan has no artifact');
+    if (artifact.erc7739.kind !== 'none') {
+        throw new Error('ERC-7739 is not a message-signing operation');
+    }
+    const step = (failureStage, operation) => runSigningStep({
+        plan: input.plan,
+        failureStage,
+        stageId: input.stage.stageId,
+        artifactId: artifact.id,
+        usage: artifact.usage,
+        operation,
+    });
+    const contribution = step('validator-encode', () => encodePlannedValidatorContribution({
+        artifact,
+        stage: input.stage,
+        results: input.results,
+    }));
+    const accountSignature = artifact.accountEnvelope.kind === 'none'
+        ? contribution
+        : step('account-envelope', () => context.accountAdapter.encodeSignatureEnvelope({
+            account: context.account,
+            envelope: artifact.accountEnvelope,
+            validatorContribution: contribution,
+            purpose: 'erc1271',
+        }));
+    const erc6492 = artifact.erc6492;
+    if (erc6492.kind === 'none') {
+        return { [artifact.id]: accountSignature };
+    }
+    const deployed = input.stage.facts.find((fact) => fact.kind === 'account-deployed');
+    return {
+        [artifact.id]: deployed?.kind === 'account-deployed' && deployed.deployed
+            ? accountSignature
+            : step('protocol-operation', () => wrapErc6492Signature({
+                factory: erc6492.factory,
+                factoryData: erc6492.factoryData,
+                signature: accountSignature,
+            })),
+    };
+}

package/dist/src/signing/passkeys.d.ts

@@ -0,0 +1,28 @@
+import type { Address, Hex } from 'viem';
+import { type WebAuthnSignature } from '../modules/validators/webauthn.js';
+export declare function parsePublicKey(publicKey: Hex | Uint8Array): {
+    x: bigint;
+    y: bigint;
+};
+export declare function parseSignature(signature: Hex | Uint8Array): {
+    r: bigint;
+    s: bigint;
+};
+export declare function generateCredentialId(pubKeyX: bigint, pubKeyY: bigint, account: Address): `0x${string}`;
+export declare function packSignature(credIds: Hex[], usePrecompile: boolean, webAuthns: {
+    authenticatorData: Hex;
+    clientDataJSON: string;
+    challengeIndex: bigint;
+    typeIndex: bigint;
+    r: bigint;
+    s: bigint;
+}[]): Hex;
+export declare function packSignatureV0(webauthn: {
+    authenticatorData: Hex;
+    clientDataJSON: string;
+    typeIndex: number | bigint;
+    r: bigint;
+    s: bigint;
+}, usePrecompiled: boolean): `0x${string}`;
+export type { WebAuthnSignature };
+//# sourceMappingURL=passkeys.d.ts.map

package/dist/src/signing/passkeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"passkeys.d.ts","sourceRoot":"","sources":["../../../signing/passkeys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AACxC,OAAO,EAML,KAAK,iBAAiB,EACvB,MAAM,gCAAgC,CAAA;AAEvC,wBAAgB,cAAc,CAAC,SAAS,EAAE,GAAG,GAAG,UAAU,GAAG;IAC3D,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAGA;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,GAAG,GAAG,UAAU,GAAG;IAC3D,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAEA;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,GACf,KAAK,MAAM,EAAE,CAEf;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,GAAG,EAAE,EACd,aAAa,EAAE,OAAO,EACtB,SAAS,EAAE;IACT,iBAAiB,EAAE,GAAG,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,EAAE,GACF,GAAG,CAEL;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE;IACR,iBAAiB,EAAE,GAAG,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,EACD,cAAc,EAAE,OAAO,GACtB,KAAK,MAAM,EAAE,CAKf;AAED,YAAY,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/src/signing/passkeys.js

@@ -0,0 +1,17 @@
+import { encodeWebauthnSignatures, encodeWebauthnSignatureV0, generateWebauthnCredentialId, parseWebauthnPublicKey, parseWebauthnSignature, } from '../modules/validators/webauthn.js';
+export function parsePublicKey(publicKey) {
+    const { x, y } = parseWebauthnPublicKey(publicKey);
+    return { x, y };
+}
+export function parseSignature(signature) {
+    return parseWebauthnSignature(signature);
+}
+export function generateCredentialId(pubKeyX, pubKeyY, account) {
+    return generateWebauthnCredentialId(pubKeyX, pubKeyY, account);
+}
+export function packSignature(credIds, usePrecompile, webAuthns) {
+    return encodeWebauthnSignatures(credIds, usePrecompile, webAuthns);
+}
+export function packSignatureV0(webauthn, usePrecompiled) {
+    return encodeWebauthnSignatureV0({ ...webauthn, typeIndex: BigInt(webauthn.typeIndex) }, usePrecompiled);
+}

package/dist/src/signing/plan.d.ts

@@ -0,0 +1,35 @@
+import type { ResolvedValidatorDefinition } from '../modules/validators/types.js';
+import type { ArtifactAssemblyPlan, ConfiguredValidatorTopology, EffectiveSignerSelection, MaterializedSigningStage, PayloadSigningTask, SigningArtifact, SigningPayloadIdentity, SigningPayloadRegistry, SigningPlan, SigningPlanKind, SigningReadCheckpoint, SigningRuntimeFact, SigningStagePlan } from './types.js';
+export declare function validateSigningPlan(plan: SigningPlan): void;
+export declare function materializeSigningStage(input: {
+    readonly plan: SigningPlan;
+    readonly stage: SigningStagePlan;
+    readonly payloads: SigningPayloadRegistry;
+    readonly facts: readonly SigningRuntimeFact[];
+    readonly priorOutputs: Readonly<Record<string, SigningArtifact>>;
+}): MaterializedSigningStage;
+export declare function createSingleStageSigningPlan(input: {
+    readonly kind: SigningPlanKind;
+    readonly payload: SigningPayloadIdentity;
+    readonly configuredTopology: ConfiguredValidatorTopology;
+    readonly effectiveSelection: EffectiveSignerSelection;
+    readonly stageId: string;
+    readonly checkpoint?: SigningReadCheckpoint;
+    readonly chain?: import('../chains/types.js').EvmChainReference;
+    readonly tasks: readonly PayloadSigningTask[];
+    readonly artifacts: readonly Omit<ArtifactAssemblyPlan, 'stageId' | 'input'>[];
+}): SigningPlan;
+export declare function createValidatorSigningTasks(input: {
+    readonly validator: ResolvedValidatorDefinition;
+    readonly signerReferences: Readonly<Record<string, import('./types.js').SignerReference>>;
+    readonly taskPrefix: string;
+    readonly ecdsaInvocation: 'ecdsa-sign-message' | 'ecdsa-sign-typed-data';
+    readonly webauthnInvocation: 'webauthn-sign-hash' | 'webauthn-sign-typed-data';
+    readonly role?: import('./types.js').SigningTaskRole;
+    readonly selectedSignerIds?: readonly string[];
+}): readonly PayloadSigningTask[];
+export declare function signingTopology(validator: ResolvedValidatorDefinition, selectedSignerIds?: readonly string[]): {
+    readonly configuredTopology: ConfiguredValidatorTopology;
+    readonly effectiveSelection: EffectiveSignerSelection;
+};
+//# sourceMappingURL=plan.d.ts.map

package/dist/src/signing/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../signing/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAE9E,OAAO,KAAK,EACV,oBAAoB,EACpB,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EAEtB,sBAAsB,EACtB,WAAW,EACX,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EAGjB,MAAM,SAAS,CAAA;AAEhB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAiO3D;AAUD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAA;IAChC,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAA;IACzC,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAC7C,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAA;CACjE,GAAG,wBAAwB,CAmB3B;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAA;IACxC,QAAQ,CAAC,kBAAkB,EAAE,2BAA2B,CAAA;IACxD,QAAQ,CAAC,kBAAkB,EAAE,wBAAwB,CAAA;IACrD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,qBAAqB,CAAA;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,iBAAiB,EAAE,iBAAiB,CAAA;IAC5D,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAC7C,QAAQ,CAAC,SAAS,EAAE,SAAS,IAAI,CAAC,oBAAoB,EAAE,SAAS,GAAG,OAAO,CAAC,EAAE,CAAA;CAC/E,GAAG,WAAW,CAiDd;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,QAAQ,CAAC,SAAS,EAAE,2BAA2B,CAAA;IAC/C,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,CACjC,MAAM,CAAC,MAAM,EAAE,OAAO,SAAS,EAAE,eAAe,CAAC,CAClD,CAAA;IACD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,eAAe,EAAE,oBAAoB,GAAG,uBAAuB,CAAA;IACxE,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,GAAG,0BAA0B,CAAA;IAC9E,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,SAAS,EAAE,eAAe,CAAA;IACjD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/C,GAAG,SAAS,kBAAkB,EAAE,CAqDhC;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,2BAA2B,EACtC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,GACpC;IACD,QAAQ,CAAC,kBAAkB,EAAE,2BAA2B,CAAA;IACxD,QAAQ,CAAC,kBAAkB,EAAE,wBAAwB,CAAA;CACtD,CA8BA"}