@rhinestone/sdk 2.0.0-beta.8 → 2.0.0

package/dist/src/transactions/intents/session-signing.js

@@ -0,0 +1,363 @@
+import { encodePacked, hashMessage, pad, } from 'viem';
+import { getChainById } from '../../chains/catalog.js';
+import { getValidatorCapabilities } from '../../modules/validators/capabilities.js';
+import { defineValidator } from '../../modules/validators/definition.js';
+import { buildPermit2ClaimPolicyCalldata } from '../../modules/validators/policies/claim/permit2.js';
+import { resolveAtomicValidator, resolveValidator, } from '../../modules/validators/resolve.js';
+import { getSessionData } from '../../modules/validators/smart-sessions/digest.js';
+import { getSmartSessionEmissaryAddress } from '../../modules/validators/smart-sessions/module.js';
+import { resolvePermit2ClaimPolicy, selectPermit2ClaimPolicyForMessage, } from '../../modules/validators/smart-sessions/policies/claim.js';
+import { getAccountSignatureEnvelope } from '../../signing/context.js';
+import { createValidatorSigningTasks, signingTopology, } from '../../signing/plan.js';
+import { createSignerInvocationPort } from '../../signing/signers/registry.js';
+export function createIntentSessionSignerInvoker(prepared, fallback) {
+    const signers = {};
+    for (const resolved of Object.values(prepared.resolvedSessions ?? {})) {
+        const validator = defineValidator(resolved.session.owners, 'smart-session-validator');
+        const owners = validator.kind === 'multi-factor'
+            ? validator.validators.flatMap(({ owners: factorOwners }) => factorOwners)
+            : validator.owners;
+        for (const owner of owners) {
+            signers[owner.signerId] =
+                owner.kind === 'webauthn'
+                    ? { kind: 'webauthn', account: owner.account }
+                    : { kind: 'ecdsa', account: owner.account };
+        }
+    }
+    const session = createSignerInvocationPort({
+        signers,
+        resolveChain: (chain) => getChainById(chain.id),
+    });
+    return {
+        has: (signer) => session.has?.(signer) ?? fallback.has?.(signer) ?? false,
+        invoke: (signer, invocation) => session.has?.(signer)
+            ? session.invoke(signer, invocation)
+            : fallback.invoke(signer, invocation),
+    };
+}
+export function buildSessionIntentPlanInput(prepared, context) {
+    const payloads = {};
+    const stages = [];
+    for (const [index, origin] of prepared.signing.origins.entries()) {
+        const session = requireSession(prepared, origin.chain.id);
+        stages.push(buildSessionStage({
+            id: `origin-${index}`,
+            outputId: `origin-${index}`,
+            usage: 'intent-origin',
+            typedData: origin.typedData,
+            payloadId: origin.id,
+            chain: origin.chain,
+            session,
+            environment: requireSessionEnvironment(prepared),
+            context,
+            payloads,
+            output: session.verifyExecutions ? 'pair' : 'notarized',
+        }));
+    }
+    const destination = prepared.signing.destination;
+    if (destination?.mode === 'sign') {
+        const session = requireSession(prepared, destination.payload.chain.id);
+        stages.push(buildSessionStage({
+            id: 'destination',
+            outputId: destination.artifactId,
+            usage: 'intent-destination',
+            typedData: destination.payload.typedData,
+            payloadId: destination.payload.id,
+            chain: destination.payload.chain,
+            session,
+            environment: requireSessionEnvironment(prepared),
+            context,
+            payloads,
+            output: session.verifyExecutions ? 'pre-claim' : 'notarized',
+            includeNotarized: session.verifyExecutions,
+        }));
+    }
+    else if (destination) {
+        const stageId = destination.originArtifactId;
+        stages.push({
+            id: 'destination',
+            checkpoint: { kind: 'none', id: 'destination:none' },
+            priorOutputs: [
+                {
+                    stageId,
+                    outputId: destination.originArtifactId,
+                    selection: destination.selection,
+                },
+            ],
+            tasks: [],
+            schedule: [],
+            artifacts: [
+                {
+                    id: destination.artifactId,
+                    usage: 'intent-destination',
+                    input: {
+                        kind: 'reuse-artifact',
+                        stageId,
+                        artifactId: destination.originArtifactId,
+                        selection: destination.selection,
+                    },
+                    validatorCodec: { kind: 'none' },
+                    erc7739: { kind: 'none' },
+                    accountEnvelope: { kind: 'none' },
+                    erc6492: { kind: 'none' },
+                },
+            ],
+        });
+    }
+    if (prepared.signing.target) {
+        const target = prepared.signing.target;
+        stages.push(buildSessionStage({
+            id: 'target',
+            outputId: 'target',
+            usage: 'intent-target',
+            typedData: target.typedData,
+            payloadId: target.id,
+            chain: target.chain,
+            session: requireSession(prepared, target.chain.id),
+            environment: requireSessionEnvironment(prepared),
+            context,
+            payloads,
+            output: 'pre-claim',
+        }));
+    }
+    return { intent: prepared.signing, stages, payloads };
+}
+function buildSessionStage(input) {
+    const signing = sessionOwnerSigning(input.session, input.context.account.address);
+    const module = getSmartSessionEmissaryAddress(input.environment);
+    const tasks = [];
+    const artifacts = [];
+    const scheduleIds = [];
+    const checkpoint = input.session.enableData
+        ? {
+            kind: 'session-enabled',
+            id: `${input.id}:session-enabled`,
+            chain: input.chain,
+            account: input.context.account.address,
+            permissionId: input.session.session.permissionId,
+        }
+        : { kind: 'none', id: `${input.id}:none` };
+    const notarizedId = `${input.id}:notarized`;
+    if (input.output === 'pair' ||
+        input.output === 'notarized' ||
+        input.includeNotarized) {
+        const payloadId = notarizedPayload(input.context.account.address, input.payloadId);
+        input.payloads[payloadId] = {
+            kind: 'message',
+            message: { raw: payloadId },
+        };
+        const stageTasks = sessionTasks(`${notarizedId}:signer`, signing, input.chain, payloadId, 'session-notarized');
+        tasks.push(...stageTasks);
+        scheduleIds.push(...stageTasks.map(({ id }) => id));
+        artifacts.push({
+            id: input.output === 'notarized' ? input.outputId : notarizedId,
+            usage: input.output === 'notarized' ? input.usage : 'intent-notarized-claim',
+            input: {
+                kind: 'task-results',
+                taskIds: stageTasks.map(({ id }) => id),
+            },
+            validatorCodec: sessionCodec(input.session, module, signing.signerCodec, 'notarized', input.typedData),
+            ...(signing.validatorFactors
+                ? { validatorFactors: signing.validatorFactors }
+                : {}),
+            erc7739: { kind: 'none' },
+            accountEnvelope: sessionAccountEnvelope(getAccountSignatureEnvelope(input.context), module),
+            erc6492: { kind: 'none' },
+        });
+    }
+    if (input.output === 'pair' || input.output === 'pre-claim') {
+        input.payloads[input.payloadId] = {
+            kind: 'message',
+            message: { raw: input.payloadId },
+        };
+        const preClaimId = input.output === 'pre-claim' ? input.outputId : `${input.id}:pre-claim`;
+        const stageTasks = sessionTasks(`${preClaimId}:signer`, signing, input.chain, input.payloadId, 'session-pre-claim');
+        tasks.push(...stageTasks);
+        scheduleIds.push(...stageTasks.map(({ id }) => id));
+        artifacts.push({
+            id: preClaimId,
+            usage: input.output === 'pre-claim' ? input.usage : 'intent-pre-claim',
+            input: {
+                kind: 'task-results',
+                taskIds: stageTasks.map(({ id }) => id),
+            },
+            validatorCodec: sessionPreClaimCodec(input.session, module, signing.signerCodec, checkpoint.id),
+            ...(signing.validatorFactors
+                ? { validatorFactors: signing.validatorFactors }
+                : {}),
+            erc7739: { kind: 'none' },
+            accountEnvelope: { kind: 'none' },
+            erc6492: { kind: 'none' },
+        });
+    }
+    if (input.output === 'pair') {
+        artifacts.push({
+            id: input.outputId,
+            usage: input.usage,
+            input: {
+                kind: 'session-claim-pair',
+                preClaimArtifactId: `${input.id}:pre-claim`,
+                notarizedClaimArtifactId: notarizedId,
+            },
+            validatorCodec: { kind: 'none' },
+            erc7739: { kind: 'none' },
+            accountEnvelope: { kind: 'none' },
+            erc6492: { kind: 'none' },
+        });
+    }
+    return {
+        id: input.id,
+        checkpoint,
+        priorOutputs: [],
+        tasks,
+        schedule: [
+            {
+                id: `${input.id}:session-signers`,
+                execution: 'serial',
+                taskIds: scheduleIds,
+            },
+        ],
+        artifacts,
+    };
+}
+function sessionTasks(taskPrefix, signing, chain, payloadId, role) {
+    return createValidatorSigningTasks({
+        validator: signing.validator,
+        signerReferences: signing.signerReferences,
+        taskPrefix,
+        ecdsaInvocation: 'ecdsa-sign-message',
+        webauthnInvocation: 'webauthn-sign-hash',
+        role,
+    }).map((task) => ({
+        ...task,
+        chain,
+        payload: { source: 'plan-payload', payloadId },
+    }));
+}
+function sessionOwnerSigning(session, account) {
+    const validator = defineValidator(session.session.owners, 'smart-session-validator');
+    const owners = validatorOwners(validator);
+    const capabilities = getValidatorCapabilities(validator, resolveValidator(validator), 'smart-session-owner', 'intent', false);
+    return {
+        validator,
+        ...signingTopology(validator),
+        signerReferences: Object.fromEntries(owners.map((owner) => [
+            owner.signerId,
+            {
+                id: owner.signerId,
+                kind: owner.kind === 'webauthn'
+                    ? 'webauthn'
+                    : 'ecdsa',
+            },
+        ])),
+        signerCodec: withWebauthnContext(requireSessionSignerCodec(capabilities.contributionCodec), validator.kind === 'passkey', account),
+        ...(validator.kind === 'multi-factor'
+            ? {
+                validatorFactors: validator.validators.map((factor) => ({
+                    id: factor.id,
+                    publicId: factor.publicId,
+                    validator: resolveAtomicValidator(factor).address,
+                    codec: withWebauthnContext(requireAtomicSignerCodec(getValidatorCapabilities(factor, resolveAtomicValidator(factor), 'smart-session-owner', 'intent', false).contributionCodec), factor.kind === 'passkey', account),
+                })),
+            }
+            : {}),
+    };
+}
+function sessionCodec(session, validator, signerCodec, mode, typedData) {
+    return {
+        kind: 'smart-session',
+        validator: { kind: 'validator', address: validator },
+        mode,
+        permissionId: session.session.permissionId,
+        signerCodec,
+        ...(mode === 'notarized'
+            ? { claimPolicyData: claimPolicyData(session, typedData) }
+            : {}),
+    };
+}
+function sessionPreClaimCodec(session, validator, signerCodec, factId) {
+    const enabled = sessionCodec(session, validator, signerCodec, 'pre-claim');
+    if (!session.enableData)
+        return enabled;
+    return {
+        kind: 'smart-session-state',
+        factId,
+        whenEnabled: enabled,
+        whenDisabled: {
+            kind: 'smart-session',
+            validator: { kind: 'validator', address: validator },
+            mode: 'enable-and-use',
+            permissionId: session.session.permissionId,
+            signerCodec,
+            enableData: {
+                ...session.enableData,
+                session: getSessionData(session.session),
+            },
+        },
+    };
+}
+function requireSessionSignerCodec(codec) {
+    if (codec.kind === 'smart-session') {
+        throw new Error('A Smart Session owner cannot use a session validator');
+    }
+    return codec;
+}
+function requireAtomicSignerCodec(codec) {
+    if (codec.kind !== 'ordered-threshold') {
+        throw new Error('A Smart Session factor must use an atomic validator');
+    }
+    return codec;
+}
+function validatorOwners(validator) {
+    return validator.kind === 'multi-factor'
+        ? validator.validators.flatMap(({ owners }) => owners)
+        : validator.owners;
+}
+function withWebauthnContext(codec, webauthn, account) {
+    if (!webauthn || codec.kind !== 'ordered-threshold')
+        return codec;
+    return {
+        ...codec,
+        webauthn: {
+            account,
+            usePrecompile: false,
+            format: 'current',
+        },
+    };
+}
+function sessionAccountEnvelope(envelope, validator) {
+    if (envelope.kind === 'none')
+        return envelope;
+    return envelope.kind === 'kernel'
+        ? { ...envelope, validator, isRoot: false }
+        : { ...envelope, validator };
+}
+function notarizedPayload(account, payload) {
+    return hashMessage({
+        raw: encodePacked(['bytes32', 'bytes32'], [pad(account, { size: 32 }), payload]),
+    });
+}
+function claimPolicyData(session, typedData) {
+    if (!typedData ||
+        typedData.primaryType !== 'PermitBatchWitnessTransferFrom' ||
+        session.session.claimPolicies.length === 0) {
+        return undefined;
+    }
+    const message = typedData.message;
+    const policy = selectPermit2ClaimPolicyForMessage(session.session.claimPolicies, message);
+    return policy
+        ? buildPermit2ClaimPolicyCalldata(resolvePermit2ClaimPolicy(policy), message)
+        : undefined;
+}
+function requireSession(prepared, chainId) {
+    const session = prepared.resolvedSessions?.[chainId];
+    if (!session)
+        throw new Error(`Prepared session for chain ${chainId} is missing`);
+    return session;
+}
+function requireSessionEnvironment(prepared) {
+    if (!prepared.sessionEnvironment) {
+        throw new Error('Prepared Smart Session environment is missing');
+    }
+    return prepared.sessionEnvironment;
+}

package/dist/src/transactions/intents/sessions.d.ts

@@ -0,0 +1,17 @@
+import type { Hex } from 'viem';
+import type { AccountRuntime } from '../../accounts/adapter.js';
+import type { Call } from '../../calls/types.js';
+import type { ResolvedSessionSignerSet } from '../../modules/validators/smart-sessions/types.js';
+import type { IntentInput, IntentWorkflowContext } from './types.js';
+export interface PreparedIntentSessions {
+    readonly signatureMode: number;
+    readonly byChain: Readonly<Record<number, ResolvedSessionSignerSet>>;
+    readonly mockSignatures: Readonly<Record<string, Hex>>;
+    readonly preClaimCalls: Readonly<Record<number, readonly Call[]>>;
+}
+export declare function prepareIntentSessions<CompatibilityConfig>(input: {
+    readonly intent: IntentInput<CompatibilityConfig>;
+    readonly runtime: AccountRuntime;
+    readonly context: Pick<IntentWorkflowContext<CompatibilityConfig>, 'checkpoints'>;
+}): Promise<PreparedIntentSessions | undefined>;
+//# sourceMappingURL=sessions.d.ts.map

package/dist/src/transactions/intents/sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/sessions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAO7C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAA;AAC7F,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEjE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC,CAAA;IACpE,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;IACtD,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC,CAAA;CAClE;AAED,wBAAsB,qBAAqB,CAAC,mBAAmB,EAAE,KAAK,EAAE;IACtE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,mBAAmB,CAAC,CAAA;IACjD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,OAAO,EAAE,IAAI,CACpB,qBAAqB,CAAC,mBAAmB,CAAC,EAC1C,aAAa,CACd,CAAA;CACF,GAAG,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAmF9C"}

package/dist/src/transactions/intents/sessions.js

@@ -0,0 +1,85 @@
+import { buildSmartSessionMockSignature } from '../../modules/validators/smart-sessions/mock-signature.js';
+import { DUMMY_PRECLAIMOP_SELECTOR, DUMMY_PRECLAIMOP_TARGET, } from '../../modules/validators/smart-sessions/resolve.js';
+export async function prepareIntentSessions(input) {
+    const selection = input.intent.signers;
+    if (!selection || selection.kind !== 'smart-session')
+        return undefined;
+    const chains = sessionChains(input.intent);
+    const resolvedEntries = await Promise.all(chains.map(async (chain) => {
+        const selected = selection.byChain[chain.id];
+        if (!selected) {
+            throw new Error(`No session configured for chain ${chain.id}`);
+        }
+        const checkpointId = `intent-session:${chain.id}:${selected.session.permissionId}`;
+        const facts = await input.context.checkpoints.read({
+            kind: 'session-enabled',
+            id: checkpointId,
+            chain,
+            account: input.runtime.identity.address,
+            permissionId: selected.session.permissionId,
+        });
+        const enabled = facts.find((fact) => fact.kind === 'session-enabled' && fact.id === checkpointId);
+        if (enabled?.kind !== 'session-enabled') {
+            throw new Error(`Session state for chain ${chain.id} is missing`);
+        }
+        const verifyExecutions = !enabled.enabled || selected.session.hasExplicitPermissions;
+        return [
+            chain.id,
+            {
+                kind: 'smart-session',
+                session: selected.session,
+                ...(enabled.enabled || !selected.enableData
+                    ? {}
+                    : { enableData: selected.enableData }),
+                verifyExecutions,
+            },
+        ];
+    }));
+    const byChain = Object.fromEntries(resolvedEntries);
+    const mockSignatures = Object.fromEntries(resolvedEntries.map(([chainId, resolved]) => [
+        String(chainId),
+        buildSmartSessionMockSignature({
+            session: resolved.session,
+            environment: input.runtime.construction.sessions.environment,
+            chainCount: input.intent.sourceChains?.length ?? 1,
+            targetChainId: chainId,
+            shape: !resolved.verifyExecutions
+                ? 'erc1271'
+                : resolved.enableData
+                    ? 'enable'
+                    : 'use',
+        }),
+    ]));
+    const preClaimCalls = Object.fromEntries((input.intent.sourceChains ?? []).flatMap((chain) => {
+        const resolved = byChain[chain.id];
+        return resolved?.verifyExecutions && resolved.enableData
+            ? [
+                [
+                    chain.id,
+                    [
+                        {
+                            target: DUMMY_PRECLAIMOP_TARGET,
+                            value: 0n,
+                            data: DUMMY_PRECLAIMOP_SELECTOR,
+                        },
+                    ],
+                ],
+            ]
+            : [];
+    }));
+    return {
+        signatureMode: resolvedEntries.some(([, value]) => value.verifyExecutions)
+            ? 5
+            : 1,
+        byChain,
+        mockSignatures,
+        preClaimCalls,
+    };
+}
+function sessionChains(intent) {
+    const chains = new Map((intent.sourceChains ?? []).map((chain) => [chain.id, chain]));
+    if (intent.destination.kind === 'evm') {
+        chains.set(intent.destination.id, intent.destination);
+    }
+    return [...chains.values()];
+}

package/dist/src/transactions/intents/sign-transaction.d.ts

@@ -0,0 +1,10 @@
+import type { Hex } from 'viem';
+import { type IndependentOwnerSignature } from '../../signing/intent-plans/independent.js';
+import type { IntentWorkflowContext, PreparedIntent, SignedIntent } from './types.js';
+export declare function signIntent<CompatibilityConfig>(context: IntentWorkflowContext<CompatibilityConfig>, prepared: PreparedIntent<CompatibilityConfig>): Promise<SignedIntent<CompatibilityConfig>>;
+export declare function signIntentAsOwner<CompatibilityConfig>(context: IntentWorkflowContext<CompatibilityConfig>, prepared: PreparedIntent<CompatibilityConfig>, selection: {
+    readonly signerId: string;
+    readonly validatorId?: number | Hex;
+}): Promise<IndependentOwnerSignature>;
+export declare function assembleIntent<CompatibilityConfig>(context: IntentWorkflowContext<CompatibilityConfig>, prepared: PreparedIntent<CompatibilityConfig>, signatures: readonly IndependentOwnerSignature[]): Promise<SignedIntent<CompatibilityConfig>>;
+//# sourceMappingURL=sign-transaction.d.ts.map

package/dist/src/transactions/intents/sign-transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-transaction.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/sign-transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAe/B,OAAO,EAGL,KAAK,yBAAyB,EAC/B,MAAM,wCAAwC,CAAA;AAuB/C,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACd,YAAY,EACb,MAAM,SAAS,CAAA;AAEhB,wBAAsB,UAAU,CAAC,mBAAmB,EAClD,OAAO,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,EACnD,QAAQ,EAAE,cAAc,CAAC,mBAAmB,CAAC,GAC5C,OAAO,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,CAsC5C;AAED,wBAAsB,iBAAiB,CAAC,mBAAmB,EACzD,OAAO,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,EACnD,QAAQ,EAAE,cAAc,CAAC,mBAAmB,CAAC,EAC7C,SAAS,EAAE;IACT,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CACpC,GACA,OAAO,CAAC,yBAAyB,CAAC,CA0DpC;AAED,wBAAsB,cAAc,CAAC,mBAAmB,EACtD,OAAO,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,EACnD,QAAQ,EAAE,cAAc,CAAC,mBAAmB,CAAC,EAC7C,UAAU,EAAE,SAAS,yBAAyB,EAAE,GAC/C,OAAO,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,CAsD5C"}