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

package/dist/src/signing/signers/compatibility.js

@@ -0,0 +1,51 @@
+import { WalletClientNoConnectedAccountError } from '../../accounts/error.js';
+export function walletClientToAccount(walletClient) {
+    const address = walletClient.account?.address;
+    if (!address)
+        throw new WalletClientNoConnectedAccountError();
+    return {
+        address,
+        signMessage: ({ message }) => walletClient.signMessage({ account: address, message }),
+        signTypedData: (parameters) => walletClient.signTypedData({
+            account: address,
+            ...parameters,
+        }),
+        signTransaction: (transaction) => walletClient.signTransaction({
+            account: address,
+            ...transaction,
+        }),
+        client: walletClient,
+    };
+}
+export function wrapParaAccount(viemAccount, walletId) {
+    const para = viemAccount;
+    const effectiveWalletId = walletId || para.walletId || para._walletId;
+    if (effectiveWalletId)
+        para._paraWalletId = effectiveWalletId;
+    return {
+        ...viemAccount,
+        signMessage: async ({ message }) => {
+            if (!viemAccount.signMessage)
+                throw new Error('Account does not support signMessage');
+            return normalizeParaRecovery(await viemAccount.signMessage({ message }));
+        },
+        signTypedData: async (typedData) => {
+            if (!viemAccount.signTypedData) {
+                throw new Error('Account does not support signTypedData');
+            }
+            return normalizeParaRecovery(await viemAccount.signTypedData(typedData));
+        },
+        signAuthorization: viemAccount.signAuthorization
+            ? viemAccount.signAuthorization.bind(viemAccount)
+            : undefined,
+        client: viemAccount.client,
+    };
+}
+function normalizeParaRecovery(signature) {
+    const value = signature.slice(2);
+    const r = value.slice(0, 64);
+    const s = value.slice(64, 128);
+    const recovery = Number.parseInt(value.slice(128, 130), 16);
+    const normalized = recovery < 27 ? recovery + 27 : recovery;
+    return `0x${r}${s}${normalized.toString(16).padStart(2, '0')}`;
+}

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

@@ -0,0 +1,14 @@
+import { type Hex } from 'viem';
+import type { RawSignerResult, SignerInvocation } from '../types.js';
+import type { ChainResolver, ExternalSigner } from './types.js';
+export declare function invokeEcdsaSigner(input: {
+    readonly signer: Extract<ExternalSigner, {
+        readonly kind: 'ecdsa' | 'wallet-authorization';
+    }>;
+    readonly invocation: Extract<SignerInvocation, {
+        readonly kind: 'ecdsa-sign-message' | 'ecdsa-sign-typed-data' | 'sign-authorization';
+    }>;
+    readonly resolveChain?: ChainResolver;
+}): Promise<RawSignerResult>;
+export declare function normalizeRecovery(signature: Hex): Hex;
+//# sourceMappingURL=ecdsa.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../../signing/signers/ecdsa.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,GAAG,EAAqB,MAAM,MAAM,CAAA;AAE1D,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAG5D,wBAAsB,iBAAiB,CAAC,KAAK,EAAE;IAC7C,QAAQ,CAAC,MAAM,EAAE,OAAO,CACtB,cAAc,EACd;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,sBAAsB,CAAA;KAAE,CACpD,CAAA;IACD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAC1B,gBAAgB,EAChB;QACE,QAAQ,CAAC,IAAI,EACT,oBAAoB,GACpB,uBAAuB,GACvB,oBAAoB,CAAA;KACzB,CACF,CAAA;IACD,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAA;CACtC,GAAG,OAAO,CAAC,eAAe,CAAC,CAyC3B;AAQD,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,GAAG,GAAG,GAAG,CAMrD"}

package/dist/src/signing/signers/ecdsa.js

@@ -0,0 +1,54 @@
+import { concat, hexToBytes, toHex } from 'viem';
+import { selectSignerChain } from './wallet-chain.js';
+export async function invokeEcdsaSigner(input) {
+    const account = input.signer.account;
+    const chain = invocationChain(input.invocation);
+    await selectSignerChain({
+        account,
+        ...(chain ? { chain } : {}),
+        ...(input.resolveChain ? { resolveChain: input.resolveChain } : {}),
+    });
+    switch (input.invocation.kind) {
+        case 'ecdsa-sign-message': {
+            if (!account.signMessage)
+                throw new Error('Account does not support signMessage');
+            const signature = await account.signMessage({
+                message: input.invocation.message,
+            });
+            return {
+                kind: 'ecdsa-signature',
+                signature: normalizeRecovery(signature),
+            };
+        }
+        case 'ecdsa-sign-typed-data': {
+            if (!account.signTypedData)
+                throw new Error('Account does not support signTypedData');
+            const signature = await account.signTypedData(input.invocation.typedData);
+            return {
+                kind: 'ecdsa-signature',
+                signature: normalizeRecovery(signature),
+            };
+        }
+        case 'sign-authorization': {
+            if (!account.signAuthorization) {
+                throw new Error('Account does not support signAuthorization');
+            }
+            return {
+                kind: 'signed-authorization',
+                authorization: await account.signAuthorization(input.invocation.authorization),
+            };
+        }
+    }
+}
+function invocationChain(invocation) {
+    return 'chain' in invocation ? invocation.chain : undefined;
+}
+export function normalizeRecovery(signature) {
+    const bytes = hexToBytes(signature);
+    if (bytes.length !== 65)
+        return signature;
+    const recovery = bytes[64];
+    if (recovery >= 27)
+        return signature;
+    return concat([signature.slice(0, -2), toHex(recovery + 27)]);
+}

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

@@ -0,0 +1,7 @@
+import type { SignerInvocationPort } from '../types.js';
+import type { ChainResolver, ExternalSignerRegistry } from './types.js';
+export declare function createSignerInvocationPort(input: {
+    readonly signers: ExternalSignerRegistry;
+    readonly resolveChain?: ChainResolver;
+}): SignerInvocationPort;
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../signing/signers/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAGpE,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAA;IACxC,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAA;CACtC,GAAG,oBAAoB,CAiCvB"}

package/dist/src/signing/signers/registry.js

@@ -0,0 +1,33 @@
+import { invokeEcdsaSigner } from './ecdsa.js';
+import { invokeWebauthnSigner } from './webauthn.js';
+export function createSignerInvocationPort(input) {
+    return {
+        has: (reference) => {
+            const signer = input.signers[reference.id];
+            return signer !== undefined && signer.kind === reference.kind;
+        },
+        invoke: async (reference, invocation) => {
+            const signer = input.signers[reference.id];
+            if (!signer)
+                throw new Error(`Signer ${reference.id} is not registered`);
+            if (signer.kind !== reference.kind) {
+                throw new Error(`Signer ${reference.id} has kind ${signer.kind}, expected ${reference.kind}`);
+            }
+            if (invocation.kind === 'webauthn-sign-hash' ||
+                invocation.kind === 'webauthn-sign-typed-data') {
+                if (signer.kind !== 'webauthn') {
+                    throw new Error(`Signer ${reference.id} cannot invoke WebAuthn`);
+                }
+                return invokeWebauthnSigner({ signer, invocation });
+            }
+            if (signer.kind === 'webauthn') {
+                throw new Error(`Signer ${reference.id} cannot invoke ECDSA`);
+            }
+            return invokeEcdsaSigner({
+                signer,
+                invocation,
+                ...(input.resolveChain ? { resolveChain: input.resolveChain } : {}),
+            });
+        },
+    };
+}

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

@@ -0,0 +1,16 @@
+import type { Account, Chain } from 'viem';
+import type { WebAuthnAccount } from 'viem/account-abstraction';
+import type { EvmChainReference } from '../../chains/types.js';
+export type ExternalSigner = {
+    readonly kind: 'ecdsa';
+    readonly account: Account;
+} | {
+    readonly kind: 'webauthn';
+    readonly account: WebAuthnAccount;
+} | {
+    readonly kind: 'wallet-authorization';
+    readonly account: Account;
+};
+export type ExternalSignerRegistry = Readonly<Record<string, ExternalSigner>>;
+export type ChainResolver = (chain: EvmChainReference) => Chain;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../signing/signers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAA;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAE3D,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAA;AAExE,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAA;AAE7E,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,KAAK,CAAA"}

package/dist/src/signing/signers/types.js

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

package/dist/src/signing/signers/wallet-chain.d.ts

@@ -0,0 +1,9 @@
+import { type Account } from 'viem';
+import type { EvmChainReference } from '../../chains/types.js';
+import type { ChainResolver } from './types.js';
+export declare function selectSignerChain(input: {
+    readonly account: Account;
+    readonly chain?: EvmChainReference;
+    readonly resolveChain?: ChainResolver;
+}): Promise<void>;
+//# sourceMappingURL=wallet-chain.d.ts.map

package/dist/src/signing/signers/wallet-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-chain.d.ts","sourceRoot":"","sources":["../../../../signing/signers/wallet-chain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAA8B,MAAM,MAAM,CAAA;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,wBAAsB,iBAAiB,CAAC,KAAK,EAAE;IAC7C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,iBAAiB,CAAA;IAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAA;CACtC,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhB"}

package/dist/src/signing/signers/wallet-chain.js

@@ -0,0 +1,15 @@
+import { createWalletClient, custom } from 'viem';
+export async function selectSignerChain(input) {
+    if (!input.chain || !input.resolveChain)
+        return;
+    const transport = input.account.client?.transport;
+    if (!transport)
+        return;
+    const chain = input.resolveChain(input.chain);
+    const walletClient = createWalletClient({
+        account: input.account,
+        chain,
+        transport: custom(transport),
+    });
+    await walletClient.switchChain({ id: chain.id });
+}

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

@@ -0,0 +1,11 @@
+import type { RawSignerResult, SignerInvocation } from '../types.js';
+import type { ExternalSigner } from './types.js';
+export declare function invokeWebauthnSigner(input: {
+    readonly signer: Extract<ExternalSigner, {
+        readonly kind: 'webauthn';
+    }>;
+    readonly invocation: Extract<SignerInvocation, {
+        readonly kind: 'webauthn-sign-hash' | 'webauthn-sign-typed-data';
+    }>;
+}): Promise<RawSignerResult>;
+//# sourceMappingURL=webauthn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webauthn.d.ts","sourceRoot":"","sources":["../../../../signing/signers/webauthn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC,CAAA;IACvE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAC1B,gBAAgB,EAChB;QAAE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,GAAG,0BAA0B,CAAA;KAAE,CACrE,CAAA;CACF,GAAG,OAAO,CAAC,eAAe,CAAC,CAc3B"}

package/dist/src/signing/signers/webauthn.js

@@ -0,0 +1,14 @@
+export async function invokeWebauthnSigner(input) {
+    const result = input.invocation.kind === 'webauthn-sign-hash'
+        ? await input.signer.account.sign({ hash: input.invocation.hash })
+        : await input.signer.account.signTypedData(input.invocation.typedData);
+    return {
+        kind: 'webauthn-assertion',
+        signature: result.signature,
+        authenticatorData: result.webauthn.authenticatorData,
+        clientDataJSON: result.webauthn.clientDataJSON,
+        challengeIndex: result.webauthn.challengeIndex ?? 0,
+        typeIndex: result.webauthn.typeIndex ?? 0,
+        userVerificationRequired: result.webauthn.userVerificationRequired ?? false,
+    };
+}

package/dist/src/signing/typed-data.d.ts

@@ -0,0 +1,39 @@
+import { type Hex, type TypedDataDefinition } from 'viem';
+import type { EvmChainReference } from '../chains/types.js';
+import type { SigningContext } from './context.js';
+import { type SigningStageAssemblyInput } from './execute.js';
+import type { ArtifactAssemblyPlan, ConfiguredValidatorTopology, EffectiveSignerSelection, PayloadSigningTask, SigningCheckpointPort, SigningPayloadMaterial, SigningPlan, SigningTranscript } from './types.js';
+export interface TypedDataSigningPlanInput {
+    readonly typedData: TypedDataDefinition;
+    readonly signingMaterial?: SigningPayloadMaterial;
+    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 resolveAccountTypedDataSigning(input: {
+    readonly typedData: TypedDataDefinition;
+    readonly chain: EvmChainReference;
+    readonly context: SigningContext;
+}): {
+    readonly material: SigningPayloadMaterial;
+    readonly payloadKind: 'message' | 'typed-data';
+    readonly ecdsaInvocation: 'ecdsa-sign-message' | 'ecdsa-sign-typed-data';
+    readonly webauthnInvocation: 'webauthn-sign-hash' | 'webauthn-sign-typed-data';
+    readonly erc7739: ArtifactAssemblyPlan['erc7739'];
+};
+export declare function createTypedDataSigningPlan(input: TypedDataSigningPlanInput): SigningPlan;
+export declare function signAccountTypedData(input: {
+    readonly planInput: TypedDataSigningPlanInput;
+    readonly context: SigningContext;
+    readonly checkpoints: SigningCheckpointPort;
+}): Promise<{
+    readonly signature: Hex;
+    readonly transcript: SigningTranscript;
+}>;
+export declare function assembleTypedDataStage(input: SigningStageAssemblyInput, context: SigningContext): Readonly<Record<string, Hex>>;
+//# sourceMappingURL=typed-data.d.ts.map

package/dist/src/signing/typed-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-data.d.ts","sourceRoot":"","sources":["../../../signing/typed-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,GAAG,EAAiB,KAAK,mBAAmB,EAAE,MAAM,MAAM,CAAA;AAOhF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAG/C,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,WAAW,CAAA;AAO9E,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,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,sBAAsB,CAAA;IACjD,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,8BAA8B,CAAC,KAAK,EAAE;IACpD,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;CACjC,GAAG;IACF,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAA;IACzC,QAAQ,CAAC,WAAW,EAAE,SAAS,GAAG,YAAY,CAAA;IAC9C,QAAQ,CAAC,eAAe,EAAE,oBAAoB,GAAG,uBAAuB,CAAA;IACxE,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,GAAG,0BAA0B,CAAA;IAC9E,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAA;CAClD,CAsCA;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,yBAAyB,GAC/B,WAAW,CAkBb;AAED,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAA;IAC7C,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,CAmBD;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,yBAAyB,EAChC,OAAO,EAAE,cAAc,GACtB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAgE/B"}

package/dist/src/signing/typed-data.js

@@ -0,0 +1,135 @@
+import { concat, hashTypedData } from 'viem';
+import { wrapKernelMessageHash } from '../accounts/adapters/kernel.js';
+import { K1_DEFAULT_VALIDATOR_ADDRESS, startaleEip712Domain, } from '../accounts/adapters/startale.js';
+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';
+import { hashErc7739TypedData, wrapErc7739TypedDataSignature, } from './protocols/erc7739.js';
+export function resolveAccountTypedDataSigning(input) {
+    const payload = hashTypedData(input.typedData);
+    const accountKind = input.context.account.definition.kind;
+    const startaleK1 = accountKind === 'startale' &&
+        input.context.validatorCapabilities.compatibilityKey.moduleAddress.toLowerCase() ===
+            K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
+    const messagePayload = accountKind === 'kernel'
+        ? wrapKernelMessageHash(payload, input.context.account.address)
+        : startaleK1
+            ? hashErc7739TypedData({
+                typedData: input.typedData,
+                verifierDomain: startaleEip712Domain(input.context.account.address, input.chain.id),
+            })
+            : input.context.validatorCapabilities.supportsEip712
+                ? undefined
+                : payload;
+    return messagePayload
+        ? {
+            material: { kind: 'message', message: { raw: messagePayload } },
+            payloadKind: 'message',
+            ecdsaInvocation: 'ecdsa-sign-message',
+            webauthnInvocation: 'webauthn-sign-hash',
+            erc7739: startaleK1
+                ? { kind: 'wrap-typed-data', typedData: input.typedData }
+                : { kind: 'none' },
+        }
+        : {
+            material: { kind: 'typed-data', typedData: input.typedData },
+            payloadKind: 'typed-data',
+            ecdsaInvocation: 'ecdsa-sign-typed-data',
+            webauthnInvocation: 'webauthn-sign-typed-data',
+            erc7739: { kind: 'none' },
+        };
+}
+export function createTypedDataSigningPlan(input) {
+    return createSingleStageSigningPlan({
+        kind: 'account-typed-data',
+        payload: { kind: 'typed-data', id: hashTypedData(input.typedData) },
+        configuredTopology: input.configuredTopology,
+        effectiveSelection: input.effectiveSelection,
+        stageId: 'typed-data',
+        ...(input.checkpoint ? { checkpoint: input.checkpoint } : {}),
+        chain: input.chain,
+        tasks: input.tasks,
+        artifacts: [
+            {
+                id: 'typed-data-signature',
+                usage: 'erc1271',
+                ...input.route,
+            },
+        ],
+    });
+}
+export async function signAccountTypedData(input) {
+    if (input.context.account.definition.kind === 'eoa') {
+        throw new EoaSigningNotSupportedError('packed signatures');
+    }
+    const plan = createTypedDataSigningPlan(input.planInput);
+    const transcript = await executeSigningPlan({
+        plan,
+        payloads: {
+            [plan.payload.id]: input.planInput.signingMaterial ?? {
+                kind: 'typed-data',
+                typedData: input.planInput.typedData,
+            },
+        },
+        checkpoints: input.checkpoints,
+        signerInvoker: input.context.signerInvoker,
+        assembleStage: (stage) => assembleTypedDataStage(stage, input.context),
+    });
+    const signature = transcript.stages[0].outputs['typed-data-signature'];
+    return { signature, transcript };
+}
+export function assembleTypedDataStage(input, context) {
+    const artifact = input.stagePlan.artifacts[0];
+    if (!artifact)
+        throw new Error('Typed-data plan has no artifact');
+    const step = (failureStage, operation) => runSigningStep({
+        plan: input.plan,
+        failureStage,
+        stageId: input.stage.stageId,
+        artifactId: artifact.id,
+        usage: artifact.usage,
+        operation,
+    });
+    let contribution = step('validator-encode', () => encodePlannedValidatorContribution({
+        artifact,
+        stage: input.stage,
+        results: input.results,
+    }));
+    const erc7739 = artifact.erc7739;
+    if (erc7739.kind !== 'none') {
+        contribution = step('protocol-operation', () => {
+            const wrapped = wrapErc7739TypedDataSignature({
+                typedData: erc7739.typedData,
+                signature: contribution,
+            });
+            return erc7739.kind === 'wrap-session-typed-data'
+                ? concat([erc7739.permissionId, wrapped])
+                : wrapped;
+        });
+    }
+    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,
+            })),
+    };
+}