@rhinestone/sdk 2.0.0-beta.44 → 2.0.0-beta.46

package/dist/src/signing/eip7702.js

@@ -0,0 +1,215 @@
+import { encodeAbiParameters, hashTypedData, keccak256, } from 'viem';
+import { executeSigningPlan } from './execute.js';
+export function createNexusEip7702InitTypedData(input) {
+    return {
+        domain: { name: 'Nexus', version: '1.2.0' },
+        types: {
+            Initialize: [
+                { name: 'nexus', type: 'address' },
+                { name: 'chainIds', type: 'uint256[]' },
+                { name: 'initData', type: 'bytes' },
+            ],
+        },
+        primaryType: 'Initialize',
+        message: {
+            nexus: input.contract,
+            chainIds: [0n],
+            initData: input.initData,
+        },
+    };
+}
+export function createNexusEip7702InitPlan(input) {
+    const payloadId = hashTypedData(input.typedData);
+    return directSigningPlan({
+        kind: 'nexus-eip7702-init',
+        payload: { kind: 'typed-data', id: payloadId },
+        stageId: 'nexus-eip7702-init',
+        task: {
+            id: 'nexus-eip7702-init-signer',
+            signer: input.signer,
+            role: 'owner',
+            invocationKind: 'ecdsa-sign-typed-data',
+            payload: { source: 'plan-payload', payloadId },
+        },
+        artifactId: 'nexus-eip7702-init-signature',
+    });
+}
+export async function signNexusEip7702Init(input) {
+    const plan = createNexusEip7702InitPlan(input.planInput);
+    const transcript = await executeDirectPlan({
+        plan,
+        payloads: {
+            [plan.payload.id]: {
+                kind: 'typed-data',
+                typedData: input.planInput.typedData,
+            },
+        },
+        signerInvoker: input.signerInvoker,
+        checkpoints: input.checkpoints,
+        artifactId: 'nexus-eip7702-init-signature',
+    });
+    const signature = transcript.stages[0].outputs['nexus-eip7702-init-signature'];
+    return { signature, transcript };
+}
+export function createAuthorizationListPlan(input) {
+    const chains = dedupeEvmChains(input.chains);
+    const payloadId = keccak256(encodeAbiParameters([{ type: 'address' }, { type: 'uint256[]' }], [input.contract, chains.map(({ id }) => BigInt(id))]));
+    const payloads = {};
+    const stages = chains.map((chain) => {
+        const nonce = input.nonceByChain[chain.id];
+        if (nonce === undefined) {
+            throw new Error(`Authorization nonce for chain ${chain.id} is missing`);
+        }
+        const chainPayloadId = keccak256(encodeAbiParameters([{ type: 'bytes32' }, { type: 'uint256' }], [payloadId, BigInt(chain.id)]));
+        payloads[chainPayloadId] = {
+            kind: 'authorization',
+            authorization: {
+                contractAddress: input.contract,
+                chainId: chain.id,
+                nonce,
+            },
+        };
+        const taskId = `authorization-${chain.id}`;
+        const factId = `delegation-${chain.id}`;
+        return {
+            id: `authorization-chain-${chain.id}`,
+            checkpoint: {
+                kind: 'delegation-code',
+                id: factId,
+                chain,
+                account: input.account,
+            },
+            priorOutputs: [],
+            taskTemplates: [
+                {
+                    id: taskId,
+                    signer: input.signer,
+                    role: 'authorization',
+                    chain,
+                    invocationKind: 'sign-authorization',
+                    payload: {
+                        source: 'plan-payload',
+                        payloadId: chainPayloadId,
+                    },
+                    when: {
+                        kind: 'delegation-required',
+                        factId,
+                        contract: input.contract,
+                    },
+                    contribution: { kind: 'authorization' },
+                },
+            ],
+            schedule: [
+                {
+                    id: `authorization-prompt-${chain.id}`,
+                    execution: 'serial',
+                    taskIds: [taskId],
+                },
+            ],
+            artifacts: [],
+        };
+    });
+    const plan = {
+        version: 1,
+        kind: 'eip7702-authorization-list',
+        payload: { kind: 'authorization', id: payloadId },
+        configuredTopology: emptyTopology,
+        effectiveSelection: emptySelection,
+        stages,
+        publicOutputs: stages.map((stage) => ({
+            id: `${stage.id}-result`,
+            source: { kind: 'task-result', taskId: stage.taskTemplates[0].id },
+            exposedForIndependentSigning: false,
+        })),
+    };
+    return { plan, payloads };
+}
+export async function signAuthorizationList(input) {
+    const { plan, payloads } = createAuthorizationListPlan(input.planInput);
+    const transcript = await executeSigningPlan({
+        plan,
+        payloads,
+        signerInvoker: input.signerInvoker,
+        checkpoints: input.checkpoints,
+        assembleStage: () => ({}),
+    });
+    const authorizations = transcript.stages.flatMap(({ results }) => Object.values(results).flatMap((result) => result.kind === 'signed-authorization' ? [result.authorization] : []));
+    return { authorizations, transcript };
+}
+function directSigningPlan(input) {
+    return {
+        version: 1,
+        kind: input.kind,
+        payload: input.payload,
+        configuredTopology: emptyTopology,
+        effectiveSelection: emptySelection,
+        stages: [
+            {
+                id: input.stageId,
+                checkpoint: { kind: 'none', id: `${input.stageId}-no-read` },
+                priorOutputs: [],
+                taskTemplates: [input.task],
+                schedule: [
+                    {
+                        id: `${input.stageId}-signer`,
+                        execution: 'serial',
+                        taskIds: [input.task.id],
+                    },
+                ],
+                artifacts: [
+                    {
+                        id: input.artifactId,
+                        stageId: input.stageId,
+                        usage: 'erc1271',
+                        input: { kind: 'task-results', taskIds: [input.task.id] },
+                        validatorCodec: { kind: 'none' },
+                        erc7739: { kind: 'none' },
+                        accountEnvelope: { kind: 'none' },
+                        erc6492: { kind: 'none' },
+                    },
+                ],
+            },
+        ],
+        publicOutputs: [
+            {
+                id: input.artifactId,
+                source: { kind: 'artifact', artifactId: input.artifactId },
+                exposedForIndependentSigning: false,
+            },
+        ],
+    };
+}
+async function executeDirectPlan(input) {
+    return executeSigningPlan({
+        plan: input.plan,
+        payloads: input.payloads,
+        signerInvoker: input.signerInvoker,
+        checkpoints: input.checkpoints,
+        assembleStage: ({ results }) => {
+            const result = Object.values(results)[0];
+            if (result?.kind !== 'ecdsa-signature') {
+                throw new Error('Direct signing task did not return an ECDSA signature');
+            }
+            return { [input.artifactId]: result.signature };
+        },
+    });
+}
+function dedupeEvmChains(chains) {
+    const seen = new Set();
+    return chains.flatMap((chain) => {
+        if (chain.kind !== 'evm' || seen.has(chain.id))
+            return [];
+        seen.add(chain.id);
+        return [chain];
+    });
+}
+const emptyTopology = {
+    rootValidatorId: 'none',
+    validators: [],
+    threshold: 0,
+};
+const emptySelection = {
+    validatorIds: [],
+    signerIds: [],
+    threshold: 0,
+};

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

@@ -0,0 +1,27 @@
+import type { EvmChainReference } from '../chains/types.js';
+import type { SignatureUsage, SigningPayloadKind, SigningPlan, SigningPlanKind, SigningTaskRole } from './types.js';
+export type SigningFailureStage = 'plan' | 'read' | 'invoke' | 'validator-encode' | 'account-envelope' | 'protocol-operation' | 'final-assembly';
+export interface SigningErrorContext {
+    readonly planKind: SigningPlanKind;
+    readonly payloadKind: SigningPayloadKind;
+    readonly failureStage: SigningFailureStage;
+    readonly stageId?: string;
+    readonly taskId?: string;
+    readonly artifactId?: string;
+    readonly usage?: SignatureUsage;
+    readonly signerRole?: SigningTaskRole;
+    readonly chain?: EvmChainReference;
+}
+export declare class SigningPipelineError extends Error {
+    readonly context: SigningErrorContext;
+    constructor(message: string, context: SigningErrorContext, options?: ErrorOptions);
+}
+export declare function runSigningStep<Result>(input: {
+    readonly plan: SigningPlan;
+    readonly failureStage: SigningFailureStage;
+    readonly stageId: string;
+    readonly artifactId: string;
+    readonly usage: SignatureUsage;
+    readonly operation: () => Result;
+}): Result;
+//# sourceMappingURL=error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../signing/error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,eAAe,EAChB,MAAM,SAAS,CAAA;AAEhB,MAAM,MAAM,mBAAmB,GAC3B,MAAM,GACN,MAAM,GACN,QAAQ,GACR,kBAAkB,GAClB,kBAAkB,GAClB,oBAAoB,GACpB,gBAAgB,CAAA;AAEpB,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;IAClC,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;IACxC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAA;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAA;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,iBAAiB,CAAA;CACnC;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;gBAGnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,YAAY;CAMzB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE;IAC5C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAA;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,MAAM,CAAA;CACjC,GAAG,MAAM,CAkBT"}

package/dist/src/signing/error.js

@@ -0,0 +1,25 @@
+export class SigningPipelineError extends Error {
+    context;
+    constructor(message, context, options) {
+        super(message, options);
+        this.name = 'SigningPipelineError';
+        this.context = context;
+    }
+}
+export function runSigningStep(input) {
+    try {
+        return input.operation();
+    }
+    catch (cause) {
+        if (cause instanceof SigningPipelineError)
+            throw cause;
+        throw new SigningPipelineError(`Signing artifact ${input.artifactId} failed during ${input.failureStage}`, {
+            planKind: input.plan.kind,
+            payloadKind: input.plan.payload.kind,
+            failureStage: input.failureStage,
+            stageId: input.stageId,
+            artifactId: input.artifactId,
+            usage: input.usage,
+        }, { cause });
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { MaterializedSigningStage, RawSignerResult, SigningArtifact, SigningCheckpointPort, SigningPayloadRegistry, SigningPlan, SigningStagePlan, SigningTranscript } from './types.js';
+export interface SigningStageAssemblyInput {
+    readonly plan: SigningPlan;
+    readonly stagePlan: SigningStagePlan;
+    readonly stage: MaterializedSigningStage;
+    readonly results: Readonly<Record<string, RawSignerResult>>;
+    readonly priorOutputs: Readonly<Record<string, SigningArtifact>>;
+}
+export type SigningStageAssembler = (input: SigningStageAssemblyInput) => Readonly<Record<string, SigningArtifact>>;
+export declare function executeSigningPlan(input: {
+    readonly plan: SigningPlan;
+    readonly payloads: SigningPayloadRegistry;
+    readonly checkpoints: SigningCheckpointPort;
+    readonly signerInvoker: import('./types.js').SignerInvocationPort;
+    readonly assembleStage: SigningStageAssembler;
+}): Promise<SigningTranscript>;
+//# sourceMappingURL=execute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../signing/execute.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAA;IACpC,QAAQ,CAAC,KAAK,EAAE,wBAAwB,CAAA;IACxC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAA;IAC3D,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAA;CACjE;AAED,MAAM,MAAM,qBAAqB,GAAG,CAClC,KAAK,EAAE,yBAAyB,KAC7B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAA;AAE9C,wBAAsB,kBAAkB,CAAC,KAAK,EAAE;IAC9C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAA;IACzC,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAA;IAC3C,QAAQ,CAAC,aAAa,EAAE,OAAO,SAAS,EAAE,oBAAoB,CAAA;IAC9D,QAAQ,CAAC,aAAa,EAAE,qBAAqB,CAAA;CAC9C,GAAG,OAAO,CAAC,iBAAiB,CAAC,CA+J7B"}

package/dist/src/signing/execute.js

@@ -0,0 +1,138 @@
+import { SigningPipelineError } from './error.js';
+import { materializeSigningStage, validateSigningPlan } from './plan.js';
+export async function executeSigningPlan(input) {
+    try {
+        validateSigningPlan(input.plan);
+    }
+    catch (cause) {
+        if (cause instanceof SigningPipelineError)
+            throw cause;
+        throw pipelineError(input.plan, 'plan', 'Signing plan validation failed', {}, cause);
+    }
+    for (const stage of input.plan.stages) {
+        for (const task of stage.taskTemplates) {
+            if (!task.when &&
+                input.signerInvoker.has &&
+                !input.signerInvoker.has(task.signer)) {
+                throw pipelineError(input.plan, 'invoke', `Missing signer ${task.signer.id}`, {
+                    stageId: stage.id,
+                    taskId: task.id,
+                    signerRole: task.role,
+                    ...(task.chain ? { chain: task.chain } : {}),
+                });
+            }
+        }
+    }
+    const priorOutputs = {};
+    const transcripts = [];
+    for (const stagePlan of input.plan.stages) {
+        let facts = [];
+        if (stagePlan.checkpoint.kind !== 'none') {
+            try {
+                facts = await input.checkpoints.read(stagePlan.checkpoint);
+            }
+            catch (cause) {
+                throw pipelineError(input.plan, 'read', `Signing checkpoint ${stagePlan.checkpoint.id} failed`, { stageId: stagePlan.id }, cause);
+            }
+        }
+        let declaredPriorOutputs;
+        let stage;
+        try {
+            declaredPriorOutputs = selectDeclaredPriorOutputs(stagePlan, priorOutputs);
+            stage = materializeSigningStage({
+                plan: input.plan,
+                stage: stagePlan,
+                payloads: input.payloads,
+                facts,
+                priorOutputs: declaredPriorOutputs,
+            });
+        }
+        catch (cause) {
+            throw pipelineError(input.plan, 'plan', `Signing stage ${stagePlan.id} materialization failed`, { stageId: stagePlan.id }, cause);
+        }
+        for (const task of stage.tasks) {
+            if (task.when &&
+                input.signerInvoker.has &&
+                !input.signerInvoker.has(task.signer)) {
+                throw pipelineError(input.plan, 'invoke', `Missing signer ${task.signer.id}`, {
+                    stageId: stage.stageId,
+                    taskId: task.id,
+                    signerRole: task.role,
+                    ...(task.chain ? { chain: task.chain } : {}),
+                });
+            }
+        }
+        const results = {};
+        const invoke = async (taskId) => {
+            const task = stage.tasks.find(({ id }) => id === taskId);
+            if (!task)
+                throw new Error(`Unknown materialized signing task ${taskId}`);
+            try {
+                results[task.id] = await input.signerInvoker.invoke(task.signer, task.invocation);
+            }
+            catch (cause) {
+                throw pipelineError(input.plan, 'invoke', `Signing task ${task.id} failed`, {
+                    stageId: stage.stageId,
+                    taskId: task.id,
+                    signerRole: task.role,
+                    ...(task.chain ? { chain: task.chain } : {}),
+                }, cause);
+            }
+        };
+        for (const batch of stage.schedule) {
+            if (batch.execution === 'parallel') {
+                await Promise.all(batch.taskIds.map(invoke));
+            }
+            else {
+                for (const taskId of batch.taskIds)
+                    await invoke(taskId);
+            }
+        }
+        let outputs;
+        try {
+            outputs = input.assembleStage({
+                plan: input.plan,
+                stagePlan,
+                stage,
+                results,
+                priorOutputs: declaredPriorOutputs,
+            });
+        }
+        catch (cause) {
+            if (cause instanceof SigningPipelineError)
+                throw cause;
+            throw pipelineError(input.plan, 'final-assembly', `Signing stage ${stage.stageId} assembly failed`, { stageId: stage.stageId }, cause);
+        }
+        for (const artifact of stagePlan.artifacts) {
+            const output = outputs[artifact.id];
+            if (output === undefined) {
+                throw pipelineError(input.plan, 'final-assembly', `Assembler omitted artifact ${artifact.id}`, { stageId: stage.stageId, artifactId: artifact.id });
+            }
+            priorOutputs[`${stage.stageId}:${artifact.id}`] = output;
+        }
+        transcripts.push({ stage, results, outputs });
+    }
+    return {
+        planKind: input.plan.kind,
+        payloadId: input.plan.payload.id,
+        stages: transcripts,
+    };
+}
+function selectDeclaredPriorOutputs(stage, outputs) {
+    return Object.fromEntries(stage.priorOutputs.map((reference) => {
+        const key = `${reference.stageId}:${reference.outputId}`;
+        const output = outputs[key];
+        if (output === undefined) {
+            throw new Error(`Declared prior output ${key} is unavailable`);
+        }
+        return [key, output];
+    }));
+}
+function pipelineError(plan, failureStage, message, context, cause) {
+    return new SigningPipelineError(message, {
+        planKind: plan.kind,
+        payloadKind: plan.payload.kind,
+        failureStage,
+        ...context,
+    }, cause === undefined ? undefined : { cause });
+}

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

@@ -0,0 +1,15 @@
+import type { Hex } from 'viem';
+import type { SigningContext } from '../context.js';
+import type { SigningStageAssemblyInput } from '../execute.js';
+import type { ArtifactAssemblyPlan, SigningArtifact } from '../types.js';
+export declare function assembleIntentStage(input: SigningStageAssemblyInput, context: SigningContext): Readonly<Record<string, SigningArtifact>>;
+export declare function assembleIntentValidatorArtifact(input: {
+    readonly artifact: ArtifactAssemblyPlan;
+    readonly context: SigningContext;
+    readonly validatorContribution: Hex;
+    readonly diagnostics?: {
+        readonly plan: SigningStageAssemblyInput['plan'];
+        readonly stageId: string;
+    };
+}): Hex;
+//# sourceMappingURL=assemble.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../../../../signing/intent-plans/assemble.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGhD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAE3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAErE,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,yBAAyB,EAChC,OAAO,EAAE,cAAc,GACtB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAsB3C;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE;IACrD,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAA;IACvC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,qBAAqB,EAAE,GAAG,CAAA;IACnC,QAAQ,CAAC,WAAW,CAAC,EAAE;QACrB,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC,MAAM,CAAC,CAAA;QAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KACzB,CAAA;CACF,GAAG,GAAG,CAsCN"}

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

@@ -0,0 +1,96 @@
+import { encodePlannedValidatorContribution } from '../contribution.js';
+import { runSigningStep } from '../error.js';
+import { wrapErc7739TypedDataSignature } from '../protocols/erc7739.js';
+export function assembleIntentStage(input, context) {
+    const outputs = {};
+    for (const artifact of input.stagePlan.artifacts) {
+        if (artifact.input.kind === 'session-claim-pair')
+            continue;
+        outputs[artifact.id] =
+            artifact.input.kind === 'reuse-artifact'
+                ? resolveReusedArtifact(artifact.id, artifact.input, input.priorOutputs)
+                : assembleSignedArtifact(input, artifact, context);
+    }
+    for (const artifact of input.stagePlan.artifacts) {
+        if (artifact.input.kind !== 'session-claim-pair')
+            continue;
+        const preClaimSig = outputs[artifact.input.preClaimArtifactId];
+        const notarizedClaimSig = outputs[artifact.input.notarizedClaimArtifactId];
+        if (typeof preClaimSig !== 'string' ||
+            typeof notarizedClaimSig !== 'string') {
+            throw new Error(`Session claim pair ${artifact.id} is incomplete`);
+        }
+        outputs[artifact.id] = { preClaimSig, notarizedClaimSig };
+    }
+    return outputs;
+}
+export function assembleIntentValidatorArtifact(input) {
+    if (input.artifact.erc6492.kind !== 'none') {
+        throw new Error('ERC-6492 is forbidden for intent signatures');
+    }
+    const step = (failureStage, operation) => input.diagnostics
+        ? runSigningStep({
+            plan: input.diagnostics.plan,
+            failureStage,
+            stageId: input.diagnostics.stageId,
+            artifactId: input.artifact.id,
+            usage: input.artifact.usage,
+            operation,
+        })
+        : operation();
+    let contribution = input.validatorContribution;
+    const erc7739 = input.artifact.erc7739;
+    if (erc7739.kind === 'wrap-typed-data') {
+        contribution = step('protocol-operation', () => wrapErc7739TypedDataSignature({
+            typedData: erc7739.typedData,
+            signature: contribution,
+        }));
+    }
+    return input.artifact.accountEnvelope.kind === 'none'
+        ? contribution
+        : step('account-envelope', () => input.context.accountAdapter.encodeSignatureEnvelope({
+            account: input.context.account,
+            envelope: input.artifact.accountEnvelope,
+            validatorContribution: contribution,
+            purpose: 'intent',
+        }));
+}
+function assembleSignedArtifact(input, artifact, context) {
+    if (artifact.validatorCodec.kind === 'none') {
+        if (artifact.input.kind !== 'task-results' ||
+            artifact.input.taskIds.length !== 1) {
+            throw new Error(`Direct artifact ${artifact.id} requires one task`);
+        }
+        const result = input.results[artifact.input.taskIds[0]];
+        if (result?.kind !== 'ecdsa-signature') {
+            throw new Error(`Direct artifact ${artifact.id} requires an ECDSA result`);
+        }
+        return result.signature;
+    }
+    return assembleIntentValidatorArtifact({
+        artifact,
+        context,
+        validatorContribution: runSigningStep({
+            plan: input.plan,
+            failureStage: 'validator-encode',
+            stageId: input.stage.stageId,
+            artifactId: artifact.id,
+            usage: artifact.usage,
+            operation: () => encodePlannedValidatorContribution({
+                artifact,
+                stage: input.stage,
+                results: input.results,
+            }),
+        }),
+        diagnostics: { plan: input.plan, stageId: input.stage.stageId },
+    });
+}
+function resolveReusedArtifact(artifactId, route, priorOutputs) {
+    const source = priorOutputs[`${route.stageId}:${route.artifactId}`];
+    if (typeof source === 'string')
+        return source;
+    if (source && route.selection === 'pre-claim' && 'preClaimSig' in source) {
+        return source.preClaimSig;
+    }
+    throw new Error(`Reused artifact ${route.artifactId} is unavailable for ${artifactId}`);
+}

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

@@ -0,0 +1,48 @@
+import type { Account, Address, Hex } from 'viem';
+import type { WebAuthnAccount } from 'viem/account-abstraction';
+import type { SigningContext } from '../context.js';
+import type { ArtifactAssemblyPlan } from '../types.js';
+export interface IndependentOwnerDescriptor {
+    readonly ownerId: string;
+    readonly identity: Address | Hex;
+    readonly kind: 'ecdsa' | 'webauthn';
+    readonly factorId?: string;
+    readonly factorPublicId?: number | Hex;
+}
+export type IndependentOwnerSignatureData = {
+    readonly kind: 'ecdsa';
+    readonly signer: Address;
+    readonly origin: readonly Hex[];
+} | {
+    readonly kind: 'passkey';
+    readonly publicKey: Hex;
+    readonly origin: readonly {
+        readonly webauthn: {
+            readonly authenticatorData: Hex;
+            readonly challengeIndex?: number;
+            readonly clientDataJSON: string;
+            readonly typeIndex?: number;
+            readonly userVerificationRequired?: boolean;
+        };
+        readonly signature: Hex;
+    }[];
+};
+export type IndependentOwnerSignature = ({
+    readonly intentId: string;
+} & IndependentOwnerSignatureData) | {
+    readonly intentId: string;
+    readonly kind: 'multi-factor';
+    readonly validatorId: number | Hex;
+    readonly signature: IndependentOwnerSignatureData;
+};
+export declare function assembleIndependentIntentArtifact(input: {
+    readonly intentId: string;
+    readonly originIndex: number;
+    readonly originCount: number;
+    readonly signatures: readonly IndependentOwnerSignature[];
+    readonly owners: readonly IndependentOwnerDescriptor[];
+    readonly artifact: ArtifactAssemblyPlan;
+    readonly context: SigningContext;
+}): Hex;
+export type IndependentSigner = Account | WebAuthnAccount;
+//# sourceMappingURL=independent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"independent.d.ts","sourceRoot":"","sources":["../../../../signing/intent-plans/independent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAY/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAGpD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,GAAG,CAAA;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAAA;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CACvC;AAED,MAAM,MAAM,6BAA6B,GACrC;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,EAAE,CAAA;CAChC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS;QACxB,QAAQ,CAAC,QAAQ,EAAE;YACjB,QAAQ,CAAC,iBAAiB,EAAE,GAAG,CAAA;YAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;YAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;YAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;YAC3B,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAA;SAC5C,CAAA;QACD,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;KACxB,EAAE,CAAA;CACJ,CAAA;AAEL,MAAM,MAAM,yBAAyB,GACjC,CAAC;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,6BAA6B,CAAC,GAC/D;IACE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,CAAA;IAClC,QAAQ,CAAC,SAAS,EAAE,6BAA6B,CAAA;CAClD,CAAA;AAEL,wBAAgB,iCAAiC,CAAC,KAAK,EAAE;IACvD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,SAAS,yBAAyB,EAAE,CAAA;IACzD,QAAQ,CAAC,MAAM,EAAE,SAAS,0BAA0B,EAAE,CAAA;IACtD,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAA;IACvC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;CACjC,GAAG,GAAG,CA2BN;AAoLD,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,eAAe,CAAA"}