@rhinestone/sdk 2.0.0-beta.9 → 2.1.0

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"}

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"}