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

package/dist/src/transactions/intents/sign-transaction.js

@@ -0,0 +1,386 @@
+import { IndependentSigningNotSupportedError, InvalidOwnerSigningOptionsError, UnknownOwnerError, } from '../../errors/execution.js';
+import { encodeValidatorId } from '../../modules/validators/multi-factor.js';
+import { createAccountSigningContext, getAccountSignatureEnvelope, getSigningValidatorCodec, getSigningValidatorFactors, } from '../../signing/context.js';
+import { executeSigningPlan } from '../../signing/execute.js';
+import { assembleIndependentIntentArtifact, } from '../../signing/intent-plans/independent.js';
+import { createIntentSigningPlan, executeIntentSigning, projectIndependentSigning, } from '../../signing/intent-plans/plan.js';
+import { createValidatorSigningTasks } from '../../signing/plan.js';
+import { resolveAccountTypedDataSigning } from '../../signing/typed-data.js';
+import { buildSessionIntentPlanInput, createIntentSessionSignerInvoker, } from './session-signing.js';
+export async function signIntent(context, prepared) {
+    const runtime = await context.account.forChain(prepared.accountChain);
+    const ownerSelection = prepared.input.signers?.kind === 'owner'
+        ? prepared.input.signers
+        : undefined;
+    const signerInvoker = prepared.resolvedSessions
+        ? createIntentSessionSignerInvoker(prepared, context.signerInvoker)
+        : context.signerInvoker;
+    const signing = createAccountSigningContext({
+        runtime,
+        purpose: 'intent',
+        signerInvoker,
+        ...(ownerSelection ? { selection: ownerSelection } : {}),
+    });
+    const planInput = prepared.resolvedSessions
+        ? buildSessionIntentPlanInput(prepared, signing)
+        : buildIntentPlanInput(prepared, signing);
+    const transcript = await executeIntentSigning({
+        planInput,
+        context: signing,
+        checkpoints: context.checkpoints,
+    });
+    const outputs = Object.assign({}, ...transcript.stages.map((stage) => stage.outputs));
+    return {
+        prepared,
+        originSignatures: prepared.signing.origins.map((_origin, index) => requireOriginSignature(outputs[`origin-${index}`])),
+        destinationSignature: requireHex(outputs.destination, 'destination'),
+        ...(prepared.signing.target
+            ? { targetSignature: requireHex(outputs.target, 'target') }
+            : {}),
+        transcript,
+    };
+}
+export async function signIntentAsOwner(context, prepared, selection) {
+    const { signing, planInput } = await createIndependentSigningInput(context, prepared);
+    const owner = findIndependentOwner(signing, selection);
+    const { plan } = projectIndependentSigning(createIntentSigningPlan(planInput), [selection.signerId], [`${owner.ownerId}`]);
+    const transcript = await executeSigningPlan({
+        plan,
+        payloads: planInput.payloads,
+        checkpoints: context.checkpoints,
+        signerInvoker: signing.signerInvoker,
+        assembleStage: () => ({}),
+    });
+    const origin = prepared.signing.origins.map((_payload, index) => {
+        const stage = transcript.stages.find(({ stage: materialized }) => materialized.stageId === `origin-${index}`);
+        const result = stage
+            ? Object.entries(stage.results).find(([taskId]) => taskId.includes(owner.ownerId))?.[1]
+            : undefined;
+        return independentOriginResult(owner, result);
+    });
+    const signature = owner.kind === 'ecdsa'
+        ? {
+            kind: 'ecdsa',
+            signer: owner.identity,
+            origin: origin,
+        }
+        : {
+            kind: 'passkey',
+            publicKey: owner.identity,
+            origin: origin,
+        };
+    return owner.factorPublicId === undefined
+        ? { intentId: prepared.quote.intentId, ...signature }
+        : {
+            intentId: prepared.quote.intentId,
+            kind: 'multi-factor',
+            validatorId: owner.factorPublicId,
+            signature,
+        };
+}
+export async function assembleIntent(context, prepared, signatures) {
+    const { signing, planInput } = await createIndependentSigningInput(context, prepared);
+    const plan = createIntentSigningPlan(planInput);
+    const owners = independentOwners(signing);
+    const assembled = Object.fromEntries(prepared.signing.origins.map((_payload, index) => {
+        const artifact = plan.stages
+            .flatMap(({ artifacts }) => artifacts)
+            .find(({ id }) => id === `origin-${index}`);
+        if (!artifact) {
+            throw new Error(`Intent origin-${index} assembly route is missing`);
+        }
+        return [
+            artifact.id,
+            assembleIndependentIntentArtifact({
+                intentId: prepared.quote.intentId,
+                originIndex: index,
+                originCount: prepared.signing.origins.length,
+                signatures,
+                owners,
+                artifact,
+                context: signing,
+            }),
+        ];
+    }));
+    if (prepared.signing.target) {
+        throw new IndependentSigningNotSupportedError();
+    }
+    const destination = prepared.signing.destination;
+    if (!destination || destination.mode !== 'reuse-origin') {
+        throw new IndependentSigningNotSupportedError();
+    }
+    const destinationSignature = assembled[destination.originArtifactId];
+    if (!destinationSignature) {
+        throw new Error('Intent destination signature is missing');
+    }
+    return {
+        prepared,
+        originSignatures: prepared.signing.origins.map((_origin, index) => {
+            const signature = assembled[`origin-${index}`];
+            if (!signature)
+                throw new Error(`Intent origin-${index} is missing`);
+            return signature;
+        }),
+        destinationSignature,
+        transcript: {
+            planKind: 'intent-full',
+            payloadId: plan.payload.id,
+            stages: [],
+        },
+    };
+}
+async function createIndependentSigningInput(context, prepared) {
+    if (prepared.resolvedSessions) {
+        throw new IndependentSigningNotSupportedError();
+    }
+    const runtime = await context.account.forChain(prepared.accountChain);
+    const signing = createAccountSigningContext({
+        runtime,
+        purpose: 'intent',
+        signerInvoker: context.signerInvoker,
+        ...(prepared.input.signers?.kind === 'owner'
+            ? { selection: prepared.input.signers }
+            : {}),
+    });
+    if (!signing.validatorCapabilities.supportsIndependentSigning) {
+        throw new IndependentSigningNotSupportedError();
+    }
+    return {
+        signing,
+        planInput: buildIntentPlanInput(prepared, signing),
+    };
+}
+function independentOwners(context) {
+    if (context.validator.kind !== 'multi-factor') {
+        return context.validator.owners.map((owner) => independentOwner(owner));
+    }
+    return context.validator.validators.flatMap((factor) => factor.owners.map((owner) => independentOwner(owner, factor.id, factor.publicId)));
+}
+function findIndependentOwner(context, selection) {
+    if (context.validator.kind !== 'multi-factor') {
+        if (selection.validatorId !== undefined) {
+            throw new InvalidOwnerSigningOptionsError({
+                context: { validatorId: selection.validatorId },
+            });
+        }
+        const owner = independentOwners(context).find((candidate) => candidate.signerId === selection.signerId);
+        if (!owner)
+            throw unknownOwner(selection);
+        return owner;
+    }
+    if (selection.validatorId === undefined) {
+        throw new InvalidOwnerSigningOptionsError({
+            context: { validatorId: selection.validatorId },
+        });
+    }
+    const factor = context.validator.validators.find((candidate) => sameValidatorId(candidate.publicId, selection.validatorId));
+    if (!factor) {
+        throw new InvalidOwnerSigningOptionsError({
+            context: { validatorId: selection.validatorId },
+        });
+    }
+    const owner = independentOwners(context).find((candidate) => candidate.factorId === factor.id &&
+        candidate.signerId === selection.signerId);
+    if (!owner)
+        throw unknownOwner(selection);
+    return owner;
+}
+function sameValidatorId(left, right) {
+    try {
+        return (encodeValidatorId(left).toLowerCase() ===
+            encodeValidatorId(right).toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
+function unknownOwner(selection) {
+    const [kind, identity] = selection.signerId.split(':', 2);
+    return new UnknownOwnerError({
+        context: {
+            ...(kind === 'webauthn' ? { publicKey: identity } : { signer: identity }),
+            ...(selection.validatorId === undefined
+                ? {}
+                : { validatorId: selection.validatorId }),
+        },
+    });
+}
+function independentOwner(owner, factorId, factorPublicId) {
+    return {
+        ownerId: owner.id,
+        signerId: owner.signerId,
+        identity: owner.kind === 'webauthn'
+            ? owner.account.publicKey
+            : owner.account.address,
+        kind: owner.kind === 'webauthn' ? 'webauthn' : 'ecdsa',
+        ...(factorId ? { factorId } : {}),
+        ...(factorPublicId === undefined ? {} : { factorPublicId }),
+    };
+}
+function independentOriginResult(owner, result) {
+    if (owner.kind === 'ecdsa') {
+        if (result?.kind !== 'ecdsa-signature') {
+            throw new Error(`Independent owner ${owner.ownerId} did not sign`);
+        }
+        return result.signature;
+    }
+    if (result?.kind !== 'webauthn-assertion') {
+        throw new Error(`Independent owner ${owner.ownerId} did not sign`);
+    }
+    return {
+        signature: result.signature,
+        webauthn: {
+            authenticatorData: result.authenticatorData,
+            challengeIndex: result.challengeIndex,
+            clientDataJSON: result.clientDataJSON,
+            typeIndex: result.typeIndex,
+            userVerificationRequired: result.userVerificationRequired,
+        },
+    };
+}
+function buildIntentPlanInput(prepared, context) {
+    const payloads = {};
+    const stages = [];
+    for (const [index, origin] of prepared.signing.origins.entries()) {
+        const route = resolveAccountTypedDataSigning({
+            typedData: origin.typedData,
+            chain: origin.chain,
+            context,
+        });
+        payloads[origin.id] = route.material;
+        stages.push(signingStage({
+            id: `origin-${index}`,
+            payloadId: origin.id,
+            chain: origin.chain,
+            usage: 'intent-origin',
+            context,
+            route,
+        }));
+    }
+    const lastOriginIndex = prepared.signing.origins.length - 1;
+    stages.push({
+        id: 'destination',
+        checkpoint: { kind: 'none', id: 'destination:none' },
+        priorOutputs: [
+            {
+                stageId: `origin-${lastOriginIndex}`,
+                outputId: `origin-${lastOriginIndex}`,
+                selection: 'whole',
+            },
+        ],
+        tasks: [],
+        schedule: [],
+        artifacts: [
+            {
+                id: 'destination',
+                usage: 'intent-destination',
+                input: {
+                    kind: 'reuse-artifact',
+                    stageId: `origin-${lastOriginIndex}`,
+                    artifactId: `origin-${lastOriginIndex}`,
+                    selection: 'whole',
+                },
+                validatorCodec: { kind: 'none' },
+                erc7739: { kind: 'none' },
+                accountEnvelope: { kind: 'none' },
+                erc6492: { kind: 'none' },
+            },
+        ],
+    });
+    if (prepared.signing.target) {
+        const target = prepared.signing.target;
+        const route = resolveAccountTypedDataSigning({
+            typedData: target.typedData,
+            chain: target.chain,
+            context,
+        });
+        payloads[target.id] = route.material;
+        stages.push(signingStage({
+            id: 'target',
+            payloadId: target.id,
+            chain: target.chain,
+            usage: 'intent-target',
+            context,
+            route,
+        }));
+    }
+    return { intent: prepared.signing, stages, payloads };
+}
+function signingStage(input) {
+    const direct = input.context.account.definition.kind === 'eoa';
+    const tasks = direct
+        ? eoaTask(input)
+        : createValidatorSigningTasks({
+            validator: input.context.validator,
+            signerReferences: input.context.signerReferences,
+            taskPrefix: input.id,
+            ecdsaInvocation: input.route.ecdsaInvocation,
+            webauthnInvocation: input.route.webauthnInvocation,
+            selectedSignerIds: input.context.effectiveSigners.signerIds,
+        }).map((task) => ({
+            ...task,
+            chain: input.chain,
+            payload: { source: 'plan-payload', payloadId: input.payloadId },
+        }));
+    const artifact = {
+        id: input.id,
+        usage: input.usage,
+        input: { kind: 'task-results', taskIds: tasks.map(({ id }) => id) },
+        validatorCodec: direct
+            ? { kind: 'none' }
+            : getSigningValidatorCodec(input.context, input.route.payloadKind),
+        ...(!direct && input.context.validator.kind === 'multi-factor'
+            ? {
+                validatorFactors: getSigningValidatorFactors(input.context, input.route.payloadKind),
+            }
+            : {}),
+        erc7739: input.route.erc7739,
+        accountEnvelope: direct
+            ? { kind: 'none' }
+            : getAccountSignatureEnvelope(input.context),
+        erc6492: { kind: 'none' },
+    };
+    return {
+        id: input.id,
+        checkpoint: { kind: 'none', id: `${input.id}:none` },
+        priorOutputs: [],
+        tasks,
+        schedule: [
+            {
+                id: `${input.id}:signers`,
+                execution: input.context.validator.kind === 'multi-factor'
+                    ? 'serial'
+                    : 'parallel',
+                taskIds: tasks.map(({ id }) => id),
+            },
+        ],
+        artifacts: [artifact],
+    };
+}
+function eoaTask(input) {
+    const signer = Object.values(input.context.signerReferences)[0];
+    if (!signer)
+        throw new Error('EOA signer is missing');
+    return [
+        {
+            id: `${input.id}:eoa`,
+            signer,
+            role: 'owner',
+            chain: input.chain,
+            invocationKind: 'ecdsa-sign-typed-data',
+            payload: { source: 'plan-payload', payloadId: input.payloadId },
+        },
+    ];
+}
+function requireOriginSignature(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value && 'preClaimSig' in value)
+        return value;
+    throw new Error('Intent origin signature is missing');
+}
+function requireHex(value, role) {
+    if (typeof value !== 'string')
+        throw new Error(`Intent ${role} signature is missing`);
+    return value;
+}

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

@@ -0,0 +1,13 @@
+import type { Address } from 'viem';
+import type { IntentSplitPort } from '../../clients/orchestrator/port.js';
+import type { OrchestratorSplitResult } from '../../clients/orchestrator/types.js';
+export declare function splitIntents(client: IntentSplitPort, input: {
+    readonly chainId: number;
+    readonly tokens: Readonly<Record<Address, bigint>>;
+    readonly settlementLayers?: {
+        readonly include: readonly string[];
+    } | {
+        readonly exclude: readonly string[];
+    };
+}): Promise<OrchestratorSplitResult>;
+//# sourceMappingURL=split.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"split.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/split.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAA;AAE/E,wBAAgB,YAAY,CAC1B,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE;IACL,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAA;IAClD,QAAQ,CAAC,gBAAgB,CAAC,EACtB;QAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GACvC;QAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAA;CAC5C,GACA,OAAO,CAAC,uBAAuB,CAAC,CAElC"}

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

@@ -0,0 +1,3 @@
+export function splitIntents(client, input) {
+    return client.splitIntents(input);
+}

package/dist/src/transactions/intents/status-policy.d.ts

@@ -0,0 +1,13 @@
+import type { OrchestratorIntentStatus } from '../../clients/orchestrator/types.js';
+import type { IntentStatus } from './types.js';
+export declare function classifyIntentStatus(status: OrchestratorIntentStatus): IntentStatus;
+export declare function getIntentRetryDelay(input: {
+    readonly error: unknown;
+    readonly now: number;
+    readonly minimum: number;
+    readonly fallback: number;
+}): {
+    readonly delay: number;
+    readonly backoff: boolean;
+} | undefined;
+//# sourceMappingURL=status-policy.d.ts.map

package/dist/src/transactions/intents/status-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-policy.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/status-policy.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAA;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAI3C,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,wBAAwB,GAC/B,YAAY,CASd;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CA4BpE"}

package/dist/src/transactions/intents/status-policy.js

@@ -0,0 +1,39 @@
+import { isConnectionError, isRateLimited, isRetryable, RateLimitedError, } from '../../clients/orchestrator/errors.js';
+const slowDelayMs = 2_000;
+export function classifyIntentStatus(status) {
+    return {
+        traceId: status.traceId,
+        intentId: status.intentId,
+        status: status.status,
+        account: status.account,
+        operations: status.operations,
+        terminal: status.status === 'COMPLETED' || status.status === 'FAILED',
+    };
+}
+export function getIntentRetryDelay(input) {
+    if (!isRetryable(input.error) &&
+        !isRateLimited(input.error) &&
+        !isConnectionError(input.error)) {
+        return undefined;
+    }
+    if (!(input.error instanceof RateLimitedError)) {
+        return { delay: input.fallback, backoff: true };
+    }
+    if (!input.error.retryAfter) {
+        return { delay: Math.max(slowDelayMs, input.minimum), backoff: false };
+    }
+    const seconds = Number(input.error.retryAfter);
+    if (!Number.isNaN(seconds)) {
+        return {
+            delay: Math.max(seconds * 1_000, input.minimum),
+            backoff: false,
+        };
+    }
+    const date = Date.parse(input.error.retryAfter);
+    return {
+        delay: Number.isNaN(date)
+            ? input.minimum
+            : Math.max(date - input.now, input.minimum),
+        backoff: false,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { IntentStatus, IntentWorkflowContext } from './types.js';
+export declare function getIntentStatus<CompatibilityConfig>(context: Pick<IntentWorkflowContext<CompatibilityConfig>, 'statusClient'>, intentId: string): Promise<IntentStatus>;
+export declare function waitForIntentStatus<CompatibilityConfig>(context: Pick<IntentWorkflowContext<CompatibilityConfig>, 'statusClient' | 'clock'>, intentId: string): Promise<IntentStatus>;
+//# sourceMappingURL=status.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/status.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAQlE,wBAAsB,eAAe,CAAC,mBAAmB,EACvD,OAAO,EAAE,IAAI,CAAC,qBAAqB,CAAC,mBAAmB,CAAC,EAAE,cAAc,CAAC,EACzE,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,CAAC,CAIvB;AAED,wBAAsB,mBAAmB,CAAC,mBAAmB,EAC3D,OAAO,EAAE,IAAI,CACX,qBAAqB,CAAC,mBAAmB,CAAC,EAC1C,cAAc,GAAG,OAAO,CACzB,EACD,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,CAAC,CAoCvB"}

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

@@ -0,0 +1,50 @@
+import { IntentFailedError } from '../../errors/execution.js';
+import { classifyIntentStatus, getIntentRetryDelay } from './status-policy.js';
+const initialDelayMs = 500;
+const slowAfterMs = 15_000;
+const slowDelayMs = 2_000;
+const initialErrorBackoffMs = 1_000;
+const maximumErrorBackoffMs = 10_000;
+export async function getIntentStatus(context, intentId) {
+    return classifyIntentStatus(await context.statusClient.getIntentStatus(intentId));
+}
+export async function waitForIntentStatus(context, intentId) {
+    const startedAt = context.clock.now();
+    let nextDelay = initialDelayMs;
+    let errorBackoff = initialErrorBackoffMs;
+    for (;;) {
+        let status;
+        try {
+            status = await getIntentStatus(context, intentId);
+            errorBackoff = initialErrorBackoffMs;
+            nextDelay =
+                context.clock.now() - startedAt >= slowAfterMs
+                    ? slowDelayMs
+                    : initialDelayMs;
+            await context.clock.sleep(nextDelay);
+        }
+        catch (error) {
+            const retryDelay = getIntentRetryDelay({
+                error,
+                now: context.clock.now(),
+                minimum: nextDelay,
+                fallback: errorBackoff,
+            });
+            if (retryDelay === undefined)
+                throw error;
+            await context.clock.sleep(retryDelay.delay);
+            if (retryDelay.backoff) {
+                errorBackoff = Math.min(errorBackoff * 2, maximumErrorBackoffMs);
+            }
+            continue;
+        }
+        if (!status.terminal)
+            continue;
+        if (status.status === 'FAILED') {
+            throw new IntentFailedError({
+                context: { intentId, operations: status.operations },
+            });
+        }
+        return status;
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { IntentWorkflowContext, SignedIntent, SubmittedIntent } from './types.js';
+export declare function submitIntent<CompatibilityConfig>(context: IntentWorkflowContext<CompatibilityConfig>, signed: SignedIntent<CompatibilityConfig>): Promise<SubmittedIntent>;
+//# sourceMappingURL=submit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"submit.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/submit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EACrB,YAAY,EACZ,eAAe,EAChB,MAAM,SAAS,CAAA;AAEhB,wBAAsB,YAAY,CAAC,mBAAmB,EACpD,OAAO,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,EACnD,MAAM,EAAE,YAAY,CAAC,mBAAmB,CAAC,GACxC,OAAO,CAAC,eAAe,CAAC,CAgC1B"}

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

@@ -0,0 +1,32 @@
+import { chainIdFromReference } from '../../chains/caip2.js';
+import { projectCompatibleIntentInput } from './compatibility.js';
+export async function submitIntent(context, signed) {
+    const response = await context.submissionClient.submitIntent({
+        intentId: signed.prepared.quote.intentId,
+        signatures: {
+            origin: signed.originSignatures,
+            destination: signed.destinationSignature,
+            ...(signed.targetSignature
+                ? { targetExecution: signed.targetSignature }
+                : {}),
+        },
+        ...(signed.authorizations && signed.authorizations.length > 0
+            ? { authorizations: { sponsor: signed.authorizations } }
+            : {}),
+        ...(signed.dryRun ? { dryRun: true } : {}),
+    }, {
+        intentInput: projectCompatibleIntentInput(signed.prepared.request),
+        sponsored: Boolean(signed.prepared.request.options.sponsorSettings),
+    });
+    return {
+        type: 'intent',
+        traceId: response.traceId,
+        intentId: response.intentId,
+        ...(signed.prepared.input.sourceChains
+            ? {
+                sourceChains: signed.prepared.input.sourceChains.map(({ id }) => id),
+            }
+            : {}),
+        targetChain: chainIdFromReference(signed.prepared.input.destination),
+    };
+}