@rhinestone/sdk 2.0.0-beta.8 → 2.0.0

package/dist/src/signing/plan.js

@@ -0,0 +1,377 @@
+import { SigningPipelineError } from './error.js';
+export function validateSigningPlan(plan) {
+    const stageIds = new Set();
+    const taskIds = new Set();
+    const artifactIds = new Set();
+    const artifactStages = new Map();
+    for (const stage of plan.stages) {
+        assertUnique(stageIds, stage.id, `Duplicate signing stage ${stage.id}`);
+        const declaredPriorOutputs = new Set();
+        for (const prior of stage.priorOutputs) {
+            const key = priorOutputKey(prior);
+            assertUnique(declaredPriorOutputs, key, `Duplicate prior output ${prior.stageId}:${prior.outputId}`);
+            if (artifactStages.get(prior.outputId) !== prior.stageId) {
+                fail(plan, `Prior output ${prior.stageId}:${prior.outputId} is unavailable`, stage.id);
+            }
+        }
+        const scheduled = new Set();
+        const stageTasks = new Set();
+        for (const task of stage.taskTemplates) {
+            assertUnique(taskIds, task.id, `Duplicate signing task ${task.id}`);
+            stageTasks.add(task.id);
+            if (task.payload.source === 'prior-output' &&
+                !declaredPriorOutputs.has(priorOutputKey(task.payload))) {
+                fail(plan, `Signing task ${task.id} uses an undeclared prior output`, stage.id);
+            }
+            if (task.payload.source === 'checkpoint-fact' &&
+                (stage.checkpoint.kind === 'none' ||
+                    task.payload.checkpointId !== stage.checkpoint.id)) {
+                fail(plan, `Signing task ${task.id} uses an undeclared checkpoint`, stage.id);
+            }
+            if (task.when &&
+                (stage.checkpoint.kind !== 'delegation-code' ||
+                    task.when.factId !== stage.checkpoint.id)) {
+                fail(plan, `Signing task ${task.id} uses an undeclared delegation fact`, stage.id);
+            }
+        }
+        for (const batch of stage.schedule) {
+            for (const taskId of batch.taskIds) {
+                if (!stageTasks.has(taskId)) {
+                    fail(plan, `Schedule references unknown task ${taskId}`, stage.id);
+                }
+                assertUnique(scheduled, taskId, `Signing task ${taskId} is scheduled more than once`);
+            }
+        }
+        if (scheduled.size !== stageTasks.size) {
+            fail(plan, `Stage ${stage.id} has unscheduled signing tasks`, stage.id);
+        }
+        for (const artifact of stage.artifacts) {
+            if (artifact.stageId !== stage.id) {
+                fail(plan, `Artifact ${artifact.id} belongs to another stage`, stage.id);
+            }
+            assertUnique(artifactIds, artifact.id, `Duplicate signing artifact ${artifact.id}`);
+            artifactStages.set(artifact.id, stage.id);
+            switch (artifact.input.kind) {
+                case 'task-results':
+                    for (const taskId of artifact.input.taskIds) {
+                        if (!stageTasks.has(taskId)) {
+                            fail(plan, `Artifact ${artifact.id} references a task outside its stage`, stage.id, artifact.id);
+                        }
+                    }
+                    break;
+                case 'reuse-artifact': {
+                    const reference = {
+                        stageId: artifact.input.stageId,
+                        outputId: artifact.input.artifactId,
+                        selection: artifact.input.selection,
+                    };
+                    if (!declaredPriorOutputs.has(priorOutputKey(reference))) {
+                        fail(plan, `Artifact ${artifact.id} uses an undeclared prior output`, stage.id, artifact.id);
+                    }
+                    break;
+                }
+                case 'session-claim-pair':
+                    for (const componentId of [
+                        artifact.input.preClaimArtifactId,
+                        artifact.input.notarizedClaimArtifactId,
+                    ]) {
+                        if (componentId === artifact.id ||
+                            artifactStages.get(componentId) !== stage.id) {
+                            fail(plan, `Session claim pair ${artifact.id} references an unavailable component`, stage.id, artifact.id);
+                        }
+                    }
+                    break;
+            }
+            if (artifact.validatorCodec.kind === 'smart-session-state' &&
+                (stage.checkpoint.kind !== 'session-enabled' ||
+                    stage.checkpoint.id !== artifact.validatorCodec.factId)) {
+                fail(plan, `Artifact ${artifact.id} uses an undeclared session-state fact`, stage.id, artifact.id);
+            }
+            if (artifact.validatorCodec.kind === 'smart-session-state') {
+                const { whenEnabled, whenDisabled } = artifact.validatorCodec;
+                if (whenEnabled.validator.address.toLowerCase() !==
+                    whenDisabled.validator.address.toLowerCase() ||
+                    whenEnabled.permissionId.toLowerCase() !==
+                        whenDisabled.permissionId.toLowerCase()) {
+                    fail(plan, `Artifact ${artifact.id} changes Smart Session identity by state`, stage.id, artifact.id);
+                }
+                if (whenEnabled.mode === 'enable-and-use' ||
+                    whenDisabled.mode !== 'enable-and-use' ||
+                    !whenDisabled.enableData) {
+                    fail(plan, `Artifact ${artifact.id} has an invalid Smart Session state route`, stage.id, artifact.id);
+                }
+            }
+            else if (artifact.validatorCodec.kind === 'smart-session' &&
+                artifact.validatorCodec.mode === 'enable-and-use' &&
+                !artifact.validatorCodec.enableData) {
+                fail(plan, `Artifact ${artifact.id} has no Smart Session enable data`, stage.id, artifact.id);
+            }
+            if (artifact.erc6492.kind !== 'none' && artifact.usage !== 'erc1271') {
+                fail(plan, `ERC-6492 is not permitted for ${artifact.usage}`, stage.id, artifact.id);
+            }
+            if (plan.kind === 'account-message' && artifact.erc7739.kind !== 'none') {
+                fail(plan, 'ERC-7739 is not a message-signing operation', stage.id, artifact.id);
+            }
+        }
+    }
+    const outputIds = new Set();
+    for (const output of plan.publicOutputs) {
+        assertUnique(outputIds, output.id, `Duplicate public output ${output.id}`);
+        if (output.source.kind === 'artifact' &&
+            !artifactIds.has(output.source.artifactId)) {
+            fail(plan, `Public output references unknown artifact ${output.source.artifactId}`);
+        }
+        if (output.source.kind === 'task-result' &&
+            !taskIds.has(output.source.taskId)) {
+            fail(plan, `Public output references unknown task ${output.source.taskId}`);
+        }
+    }
+}
+function priorOutputKey(input) {
+    return `${input.stageId}:${input.outputId}:${input.selection}`;
+}
+export function materializeSigningStage(input) {
+    return {
+        stageId: input.stage.id,
+        facts: input.facts,
+        tasks: input.stage.taskTemplates
+            .filter((template) => taskIsRequired(template, input.facts))
+            .map((template) => materializeTask(template, input)),
+        schedule: input.stage.schedule
+            .map((batch) => ({
+            ...batch,
+            taskIds: batch.taskIds.filter((taskId) => {
+                const template = input.stage.taskTemplates.find(({ id }) => id === taskId);
+                return template && taskIsRequired(template, input.facts);
+            }),
+        }))
+            .filter(({ taskIds }) => taskIds.length > 0),
+    };
+}
+export function createSingleStageSigningPlan(input) {
+    const taskTemplates = input.tasks.map((task) => ({
+        ...task,
+        ...(input.chain ? { chain: input.chain } : {}),
+        payload: { source: 'plan-payload', payloadId: input.payload.id },
+    }));
+    return {
+        version: 1,
+        kind: input.kind,
+        payload: input.payload,
+        configuredTopology: input.configuredTopology,
+        effectiveSelection: input.effectiveSelection,
+        stages: [
+            {
+                id: input.stageId,
+                checkpoint: input.checkpoint ?? {
+                    kind: 'none',
+                    id: `${input.stageId}-no-read`,
+                },
+                priorOutputs: [],
+                taskTemplates,
+                schedule: taskTemplates.length === 0
+                    ? []
+                    : [
+                        {
+                            id: `${input.stageId}-signers`,
+                            execution: 'parallel',
+                            taskIds: taskTemplates.map(({ id }) => id),
+                        },
+                    ],
+                artifacts: input.artifacts.map((artifact) => ({
+                    ...artifact,
+                    stageId: input.stageId,
+                    input: {
+                        kind: 'task-results',
+                        taskIds: taskTemplates.map(({ id }) => id),
+                    },
+                })),
+            },
+        ],
+        publicOutputs: input.artifacts.map((artifact) => ({
+            id: artifact.id,
+            source: { kind: 'artifact', artifactId: artifact.id },
+            exposedForIndependentSigning: false,
+        })),
+    };
+}
+export function createValidatorSigningTasks(input) {
+    const selectedSignerIds = input.selectedSignerIds;
+    const factors = input.validator.kind === 'multi-factor'
+        ? input.validator.validators.map((validator) => ({
+            factorId: validator.id,
+            owners: validator.owners,
+        }))
+        : [{ factorId: undefined, owners: input.validator.owners }];
+    const tasks = factors.flatMap((factor) => factor.owners.flatMap((owner) => {
+        if (selectedSignerIds && !selectedSignerIds.includes(owner.signerId)) {
+            return [];
+        }
+        const signer = input.signerReferences[owner.signerId];
+        if (!signer)
+            throw new Error(`Signer reference ${owner.signerId} is missing`);
+        const webauthn = owner.kind === 'webauthn';
+        return [
+            {
+                id: `${input.taskPrefix}:${owner.id}`,
+                signer,
+                role: input.role ?? (factor.factorId ? 'factor' : 'owner'),
+                invocationKind: webauthn
+                    ? input.webauthnInvocation
+                    : input.ecdsaInvocation,
+                contribution: webauthn
+                    ? {
+                        kind: 'webauthn',
+                        ownerId: owner.id,
+                        publicKey: owner.account.publicKey,
+                        ...(factor.factorId ? { factorId: factor.factorId } : {}),
+                    }
+                    : {
+                        kind: 'ecdsa',
+                        ownerId: owner.id,
+                        encoding: 'raw-signer',
+                        ...(factor.factorId ? { factorId: factor.factorId } : {}),
+                    },
+            },
+        ];
+    }));
+    return input.validator.kind === 'multi-factor'
+        ? [...tasks].sort((left, right) => left.invocationKind.startsWith('ecdsa') ===
+            right.invocationKind.startsWith('ecdsa')
+            ? 0
+            : left.invocationKind.startsWith('ecdsa')
+                ? -1
+                : 1)
+        : tasks;
+}
+export function signingTopology(validator, selectedSignerIds) {
+    const validators = validator.kind === 'multi-factor' ? validator.validators : [validator];
+    return {
+        configuredTopology: {
+            rootValidatorId: validator.id,
+            validators: validators.map((item) => ({
+                id: item.id,
+                ownerIds: item.owners.map(({ id }) => id),
+                threshold: item.threshold,
+            })),
+            threshold: validator.threshold,
+        },
+        effectiveSelection: {
+            validatorIds: validators.flatMap((item) => selectedSignerIds &&
+                !item.owners.some(({ signerId }) => selectedSignerIds.includes(signerId))
+                ? []
+                : [item.id]),
+            signerIds: selectedSignerIds ??
+                validators.flatMap((item) => item.owners.map(({ signerId }) => signerId)),
+            threshold: validator.threshold,
+        },
+    };
+}
+function taskIsRequired(template, facts) {
+    if (!template.when)
+        return true;
+    const fact = facts.find(({ id }) => id === template.when?.factId);
+    if (fact?.kind !== 'delegation-code') {
+        throw new Error(`Delegation fact ${template.when.factId} is missing`);
+    }
+    return (fact.code?.toLowerCase() !==
+        `0xef0100${template.when.contract.slice(2)}`.toLowerCase());
+}
+function materializeTask(template, input) {
+    const material = resolvePayloadMaterial(template, input);
+    const chain = template.chain;
+    switch (template.invocationKind) {
+        case 'ecdsa-sign-message':
+            requireMaterial(template, material, 'message');
+            return {
+                ...template,
+                invocation: {
+                    kind: 'ecdsa-sign-message',
+                    ...(chain ? { chain } : {}),
+                    message: material.message,
+                },
+            };
+        case 'ecdsa-sign-typed-data':
+            requireMaterial(template, material, 'typed-data');
+            return {
+                ...template,
+                invocation: {
+                    kind: 'ecdsa-sign-typed-data',
+                    ...(chain ? { chain } : {}),
+                    typedData: material.typedData,
+                },
+            };
+        case 'webauthn-sign-hash':
+            requireMaterial(template, material, 'message');
+            return {
+                ...template,
+                invocation: { kind: 'webauthn-sign-hash', hash: material.message.raw },
+            };
+        case 'webauthn-sign-typed-data':
+            requireMaterial(template, material, 'typed-data');
+            return {
+                ...template,
+                invocation: {
+                    kind: 'webauthn-sign-typed-data',
+                    typedData: material.typedData,
+                },
+            };
+        case 'sign-authorization':
+            requireMaterial(template, material, 'authorization');
+            if (!chain)
+                throw new Error(`Authorization task ${template.id} has no chain`);
+            return {
+                ...template,
+                invocation: {
+                    kind: 'sign-authorization',
+                    chain,
+                    authorization: material.authorization,
+                },
+            };
+    }
+}
+function resolvePayloadMaterial(template, input) {
+    const reference = template.payload;
+    if (reference.source === 'plan-payload') {
+        const material = input.payloads[reference.payloadId];
+        if (!material)
+            throw new Error(`No payload material for ${reference.payloadId}`);
+        return material;
+    }
+    if (reference.source === 'prior-output') {
+        const artifact = input.priorOutputs[`${reference.stageId}:${reference.outputId}`];
+        const selected = reference.selection === 'pre-claim' &&
+            typeof artifact === 'object' &&
+            'preClaimSig' in artifact
+            ? artifact.preClaimSig
+            : artifact;
+        if (typeof selected !== 'string') {
+            throw new Error(`Prior output ${reference.outputId} is not signable bytes`);
+        }
+        return { kind: 'message', message: { raw: selected } };
+    }
+    const fact = input.facts.find(({ id }) => id === reference.factId);
+    if (fact?.kind !== 'delegation-code' || !fact.code) {
+        throw new Error(`Checkpoint fact ${reference.factId} is not signable bytes`);
+    }
+    return { kind: 'message', message: { raw: fact.code } };
+}
+function requireMaterial(template, material, kind) {
+    if (material.kind !== kind) {
+        throw new Error(`Signing task ${template.id} requires ${kind}, received ${material.kind}`);
+    }
+}
+function assertUnique(values, value, message) {
+    if (values.has(value))
+        throw new Error(message);
+    values.add(value);
+}
+function fail(plan, message, stageId, artifactId) {
+    throw new SigningPipelineError(message, {
+        planKind: plan.kind,
+        payloadKind: plan.payload.kind,
+        failureStage: 'plan',
+        ...(stageId ? { stageId } : {}),
+        ...(artifactId ? { artifactId } : {}),
+    });
+}

package/dist/src/signing/protocols/erc6492.d.ts

@@ -0,0 +1,11 @@
+import { type Address, type Hex } from 'viem';
+export declare const ERC6492_MAGIC_BYTES: "0x6492649264926492649264926492649264926492649264926492649264926492";
+export interface Erc6492Signature {
+    readonly factory: Address;
+    readonly factoryData: Hex;
+    readonly signature: Hex;
+}
+export declare function isErc6492Signature(signature: Hex): boolean;
+export declare function wrapErc6492Signature(input: Erc6492Signature): Hex;
+export declare function unwrapErc6492Signature(signature: Hex): Erc6492Signature;
+//# sourceMappingURL=erc6492.d.ts.map

package/dist/src/signing/protocols/erc6492.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc6492.d.ts","sourceRoot":"","sources":["../../../../signing/protocols/erc6492.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,GAAG,EAGT,MAAM,MAAM,CAAA;AAEb,eAAO,MAAM,mBAAmB,EAC9B,oEAA6E,CAAA;AAE/E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;CACxB;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,GAAG,GAAG,OAAO,CAK1D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,GAAG,GAAG,CAYjE;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,GAAG,GAAG,gBAAgB,CAUvE"}

package/dist/src/signing/protocols/erc6492.js

@@ -0,0 +1,24 @@
+import { concat, decodeAbiParameters, encodeAbiParameters, size, slice, } from 'viem';
+export const ERC6492_MAGIC_BYTES = '0x6492649264926492649264926492649264926492649264926492649264926492';
+export function isErc6492Signature(signature) {
+    return (size(signature) >= 32 &&
+        slice(signature, size(signature) - 32).toLowerCase() === ERC6492_MAGIC_BYTES);
+}
+export function wrapErc6492Signature(input) {
+    return concat([
+        encodeAbiParameters([
+            { name: 'create2Factory', type: 'address' },
+            { name: 'factoryCalldata', type: 'bytes' },
+            { name: 'originalERC1271Signature', type: 'bytes' },
+        ], [input.factory, input.factoryData, input.signature]),
+        ERC6492_MAGIC_BYTES,
+    ]);
+}
+export function unwrapErc6492Signature(signature) {
+    if (!isErc6492Signature(signature)) {
+        throw new Error('Signature is not ERC-6492 encoded');
+    }
+    const encoded = slice(signature, 0, size(signature) - 32);
+    const [factory, factoryData, originalSignature] = decodeAbiParameters([{ type: 'address' }, { type: 'bytes' }, { type: 'bytes' }], encoded);
+    return { factory, factoryData, signature: originalSignature };
+}

package/dist/src/signing/protocols/erc7739.d.ts

@@ -0,0 +1,17 @@
+import { type Address, type Hex, type TypedDataDefinition } from 'viem';
+export interface Erc7739VerifierDomain {
+    readonly name: string;
+    readonly version: string;
+    readonly chainId: number;
+    readonly verifyingContract: Address;
+    readonly salt: Hex;
+}
+export declare function hashErc7739TypedData(input: {
+    readonly typedData: TypedDataDefinition;
+    readonly verifierDomain: Erc7739VerifierDomain;
+}): Hex;
+export declare function wrapErc7739TypedDataSignature(input: {
+    readonly typedData: TypedDataDefinition;
+    readonly signature: Hex;
+}): Hex;
+//# sourceMappingURL=erc7739.d.ts.map

package/dist/src/signing/protocols/erc7739.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc7739.d.ts","sourceRoot":"","sources":["../../../../signing/protocols/erc7739.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,GAAG,EAKR,KAAK,mBAAmB,EAGzB,MAAM,MAAM,CAAA;AAGb,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAA;IACnC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;CACnB;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,QAAQ,CAAC,cAAc,EAAE,qBAAqB,CAAA;CAC/C,GAAG,GAAG,CAwDN;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;CACxB,GAAG,GAAG,CASN"}

package/dist/src/signing/protocols/erc7739.js

@@ -0,0 +1,84 @@
+import { concat, encodeAbiParameters, hashDomain, hashStruct, keccak256, toHex, } from 'viem';
+import { wrapTypedDataSignature } from 'viem/experimental/erc7739';
+export function hashErc7739TypedData(input) {
+    const { domain, types, primaryType, message } = input.typedData;
+    if (!domain || !primaryType) {
+        throw new Error('ERC-7739 requires a complete typed-data definition');
+    }
+    const typeFields = types;
+    const contentsType = encodeType(primaryType, typeFields);
+    const typedDataSignTypeHash = keccak256(toHex(`TypedDataSign(${primaryType} contents,string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)${contentsType}`));
+    const contentsHash = hashStruct({
+        data: message,
+        primaryType,
+        types: typeFields,
+    });
+    const verifier = input.verifierDomain;
+    const structHash = keccak256(encodeAbiParameters([
+        { type: 'bytes32' },
+        { type: 'bytes32' },
+        { type: 'bytes32' },
+        { type: 'bytes32' },
+        { type: 'uint256' },
+        { type: 'address' },
+        { type: 'bytes32' },
+    ], [
+        typedDataSignTypeHash,
+        contentsHash,
+        keccak256(toHex(verifier.name)),
+        keccak256(toHex(verifier.version)),
+        BigInt(verifier.chainId),
+        verifier.verifyingContract,
+        verifier.salt,
+    ]));
+    const domainTypes = [];
+    if (domain.name)
+        domainTypes.push({ name: 'name', type: 'string' });
+    if (domain.version)
+        domainTypes.push({ name: 'version', type: 'string' });
+    if (domain.chainId)
+        domainTypes.push({ name: 'chainId', type: 'uint256' });
+    if (domain.verifyingContract) {
+        domainTypes.push({ name: 'verifyingContract', type: 'address' });
+    }
+    if (domain.salt)
+        domainTypes.push({ name: 'salt', type: 'bytes32' });
+    const appDomainSeparator = hashDomain({
+        domain,
+        types: { EIP712Domain: domainTypes },
+    });
+    return keccak256(concat(['0x1901', appDomainSeparator, structHash]));
+}
+export function wrapErc7739TypedDataSignature(input) {
+    const typedData = input.typedData;
+    return wrapTypedDataSignature({
+        domain: typedData.domain,
+        primaryType: typedData.primaryType,
+        types: typedData.types,
+        message: typedData.message,
+        signature: input.signature,
+    });
+}
+function encodeType(primaryType, types) {
+    const dependencies = new Set();
+    const collect = (type) => {
+        const typeName = type.match(/^\w*/)?.[0];
+        if (!typeName || dependencies.has(typeName) || !types[typeName])
+            return;
+        dependencies.add(typeName);
+        for (const field of types[typeName])
+            collect(field.type);
+    };
+    collect(primaryType);
+    dependencies.delete(primaryType);
+    return [primaryType, ...dependencies]
+        .sort((left, right) => {
+        if (left === primaryType)
+            return -1;
+        if (right === primaryType)
+            return 1;
+        return left.localeCompare(right);
+    })
+        .map((type) => `${type}(${types[type].map((field) => `${field.type} ${field.name}`).join(',')})`)
+        .join('');
+}

package/dist/src/signing/session-enable.d.ts

@@ -0,0 +1,35 @@
+import { type Address, type Hex, type TypedDataDefinition } from 'viem';
+import type { AccountKind } from '../accounts/types.js';
+import type { EvmChainReference } from '../chains/types.js';
+import type { ValidatorContributionCodec } from '../modules/validators/types.js';
+import type { SigningContext } from './context.js';
+import type { ArtifactAssemblyPlan, ConfiguredValidatorTopology, EffectiveSignerSelection, PayloadSigningTask, SigningCheckpointPort, SigningPayloadMaterial, SigningPlan, SigningTranscript } from './types.js';
+export interface SessionEnableSigningPlanInput {
+    readonly typedData: TypedDataDefinition;
+    readonly chain: EvmChainReference;
+    readonly configuredTopology: ConfiguredValidatorTopology;
+    readonly effectiveSelection: EffectiveSignerSelection;
+    readonly tasks: readonly PayloadSigningTask[];
+    readonly signingMaterial?: SigningPayloadMaterial;
+    readonly validatorCodec: ValidatorContributionCodec;
+    readonly validatorFactors?: import('./types.js').ArtifactAssemblyPlan['validatorFactors'];
+    readonly route: Pick<ArtifactAssemblyPlan, 'erc7739' | 'accountEnvelope' | 'erc6492'>;
+}
+export declare function createSessionEnableSigningPlan(input: SessionEnableSigningPlanInput): SigningPlan;
+export declare function signSessionEnablement(input: {
+    readonly planInput: SessionEnableSigningPlanInput;
+    readonly context: SigningContext;
+    readonly checkpoints: SigningCheckpointPort;
+}): Promise<{
+    readonly signature: Hex;
+    readonly transcript: SigningTranscript;
+}>;
+export declare function resolveSessionEnableChain(input: {
+    readonly accountKind: AccountKind;
+    readonly validator: Address;
+    readonly hashesAndChainIds: readonly {
+        readonly chainId: bigint;
+    }[];
+    readonly defaultChain: EvmChainReference;
+}): EvmChainReference;
+//# sourceMappingURL=session-enable.d.ts.map

package/dist/src/signing/session-enable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-enable.d.ts","sourceRoot":"","sources":["../../../signing/session-enable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,GAAG,EAGR,KAAK,mBAAmB,EACzB,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAI/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,6BAA6B;IAC5C,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,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,eAAe,CAAC,EAAE,sBAAsB,CAAA;IACjD,QAAQ,CAAC,cAAc,EAAE,0BAA0B,CAAA;IACnD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,SAAS,EAAE,oBAAoB,CAAC,kBAAkB,CAAC,CAAA;IACtF,QAAQ,CAAC,KAAK,EAAE,IAAI,CAClB,oBAAoB,EACpB,SAAS,GAAG,iBAAiB,GAAG,SAAS,CAC1C,CAAA;CACF;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,6BAA6B,GACnC,WAAW,CAqBb;AAED,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IACjD,QAAQ,CAAC,SAAS,EAAE,6BAA6B,CAAA;IACjD,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,CAkBD;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,iBAAiB,EAAE,SAAS;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACnE,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAA;CACzC,GAAG,iBAAiB,CAoBpB"}

package/dist/src/signing/session-enable.js

@@ -0,0 +1,62 @@
+import { hashTypedData, isAddressEqual, } from 'viem';
+import { toEvmChainReference } from '../chains/caip2.js';
+import { K1_DEFAULT_VALIDATOR_ADDRESS } from '../modules/validators/k1.js';
+import { executeSigningPlan } from './execute.js';
+import { createSingleStageSigningPlan } from './plan.js';
+import { assembleTypedDataStage } from './typed-data.js';
+export function createSessionEnableSigningPlan(input) {
+    return createSingleStageSigningPlan({
+        kind: 'session-enable',
+        payload: { kind: 'session-enable', id: hashTypedData(input.typedData) },
+        configuredTopology: input.configuredTopology,
+        effectiveSelection: input.effectiveSelection,
+        stageId: 'session-enable',
+        chain: input.chain,
+        tasks: input.tasks,
+        artifacts: [
+            {
+                id: 'session-enable-signature',
+                usage: 'session-enable',
+                validatorCodec: input.validatorCodec,
+                ...(input.validatorFactors
+                    ? { validatorFactors: input.validatorFactors }
+                    : {}),
+                ...input.route,
+            },
+        ],
+    });
+}
+export async function signSessionEnablement(input) {
+    const plan = createSessionEnableSigningPlan(input.planInput);
+    const transcript = await executeSigningPlan({
+        plan,
+        payloads: {
+            [plan.payload.id]: input.planInput.signingMaterial ?? {
+                kind: 'typed-data',
+                typedData: input.planInput.typedData,
+            },
+        },
+        signerInvoker: input.context.signerInvoker,
+        checkpoints: input.checkpoints,
+        assembleStage: (stage) => assembleTypedDataStage(stage, input.context),
+    });
+    const signature = transcript.stages[0].outputs['session-enable-signature'];
+    return { signature, transcript };
+}
+export function resolveSessionEnableChain(input) {
+    const startaleK1 = input.accountKind === 'startale' &&
+        isAddressEqual(input.validator, K1_DEFAULT_VALIDATOR_ADDRESS);
+    if (!startaleK1)
+        return input.defaultChain;
+    const chainIds = [
+        ...new Set(input.hashesAndChainIds.map(({ chainId }) => chainId.toString())),
+    ];
+    if (chainIds.length > 1) {
+        throw new Error('Startale accounts with K1 validator do not support multi-chain session enable');
+    }
+    const chainId = chainIds[0];
+    if (chainId === undefined) {
+        throw new Error('Startale K1 session enable requires one session chain');
+    }
+    return toEvmChainReference(Number(chainId));
+}

package/dist/src/signing/signers/compatibility.d.ts

@@ -0,0 +1,4 @@
+import type { Account, WalletClient } from 'viem';
+export declare function walletClientToAccount(walletClient: WalletClient): Account;
+export declare function wrapParaAccount(viemAccount: Account, walletId?: string): Account;
+//# sourceMappingURL=compatibility.d.ts.map

package/dist/src/signing/signers/compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility.d.ts","sourceRoot":"","sources":["../../../../signing/signers/compatibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAOP,YAAY,EACb,MAAM,MAAM,CAAA;AAGb,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CA0BzE;AAED,wBAAgB,eAAe,CAC7B,WAAW,EAAE,OAAO,EACpB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CA+BT"}