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

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAsB,MAAM,MAAM,CAAA;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AAIzE,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,mBAAmB,GAC7B,mBAAmB,CAUrB;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,iBAAiB,GACvB,iBAAiB,CAenB"}

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

@@ -0,0 +1,48 @@
+export function normalizeIntentTypedData(typedData) {
+    const types = typedData.types;
+    return {
+        ...typedData,
+        message: normalizeTypedDataMessage(types, typedData.primaryType, typedData.message),
+    };
+}
+export function normalizeIntentQuote(quote) {
+    return {
+        ...quote,
+        signData: {
+            origin: quote.signData.origin.map(normalizeIntentTypedData),
+            destination: normalizeIntentTypedData(quote.signData.destination),
+            ...(quote.signData.targetExecution
+                ? {
+                    targetExecution: normalizeIntentTypedData(quote.signData.targetExecution),
+                }
+                : {}),
+        },
+    };
+}
+function normalizeTypedDataMessage(types, primaryType, message) {
+    const fields = types[primaryType];
+    if (!fields)
+        return message;
+    return Object.fromEntries(Object.entries(message).map(([name, value]) => {
+        const type = fields.find((field) => field.name === name)?.type;
+        return [name, type ? normalizeTypedDataValue(types, type, value) : value];
+    }));
+}
+function normalizeTypedDataValue(types, type, value) {
+    if (value === null || value === undefined)
+        return value;
+    const array = type.match(/^(.+)\[\d*\]$/u);
+    if (array) {
+        return Array.isArray(value)
+            ? value.map((item) => normalizeTypedDataValue(types, array[1], item))
+            : value;
+    }
+    if (/^u?int\d*$/u.test(type)) {
+        return typeof value === 'string' || typeof value === 'number'
+            ? BigInt(value)
+            : value;
+    }
+    return types[type]
+        ? normalizeTypedDataMessage(types, type, value)
+        : value;
+}

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

@@ -0,0 +1,7 @@
+import type { AccountRuntime } from '../../accounts/adapter.js';
+import type { EvmChainReference } from '../../chains/types.js';
+import type { IntentSigningInput } from '../../signing/intent-plans/types.js';
+import type { IntentInput, IntentWorkflowContext, PreparedIntent } from './types.js';
+export declare function prepareIntent<CompatibilityConfig>(context: IntentWorkflowContext<CompatibilityConfig>, input: IntentInput<CompatibilityConfig>): Promise<PreparedIntent<CompatibilityConfig>>;
+export declare function buildIntentSigningInput(runtime: AccountRuntime, quote: PreparedIntent['quote'], sessions?: PreparedIntent['resolvedSessions'], destination?: EvmChainReference, ownerValidator?: import('../../modules/validators/types.js').ResolvedValidatorDefinition, selectedSignerIds?: readonly string[]): IntentSigningInput;
+//# sourceMappingURL=prepare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/prepare.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAI3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAO1E,OAAO,KAAK,EACV,WAAW,EACX,qBAAqB,EACrB,cAAc,EACf,MAAM,SAAS,CAAA;AAEhB,wBAAsB,aAAa,CAAC,mBAAmB,EACrD,OAAO,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,EACnD,KAAK,EAAE,WAAW,CAAC,mBAAmB,CAAC,GACtC,OAAO,CAAC,cAAc,CAAC,mBAAmB,CAAC,CAAC,CA2D9C;AA4ED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,EAC9B,QAAQ,CAAC,EAAE,cAAc,CAAC,kBAAkB,CAAC,EAC7C,WAAW,CAAC,EAAE,iBAAiB,EAC/B,cAAc,CAAC,EAAE,OAAO,gCAAgC,EAAE,2BAA2B,EACrF,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,GACpC,kBAAkB,CA2IpB"}

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

@@ -0,0 +1,249 @@
+import { hashTypedData, keccak256, stringToHex } from 'viem';
+import { resolveCalls } from '../../calls/resolve.js';
+import { chainIdFromReference, toEvmChainReference } from '../../chains/caip2.js';
+import { defineValidator } from '../../modules/validators/definition.js';
+import { ecdsaSignerId } from '../../modules/validators/signer-id.js';
+import { signingTopology } from '../../signing/plan.js';
+import { projectIntentAccount } from './account.js';
+import { normalizeIntentQuote } from './normalize.js';
+import { selectIntentQuote } from './quotes.js';
+import { buildIntentRequest } from './request.js';
+import { prepareIntentSessions } from './sessions.js';
+export async function prepareIntent(context, input) {
+    const accountChain = selectAccountChain(input);
+    const runtime = await context.account.forChain(accountChain);
+    const calls = await resolveDestinationCalls(context, input, runtime);
+    const source = await resolveSourceCalls(context, input, runtime);
+    const sessions = await prepareIntentSessions({
+        intent: input,
+        runtime,
+        context,
+    });
+    const ownerSelection = input.signers?.kind === 'owner' ? input.signers : undefined;
+    const request = buildIntentRequest({
+        transaction: sessions
+            ? { ...input, signatureMode: sessions.signatureMode }
+            : input,
+        account: {
+            ...projectIntentAccount({
+                runtime,
+                setupOverride: input.accountSetupOverride,
+                ...(input.eip7702InitSignature
+                    ? { eip7702InitSignature: input.eip7702InitSignature }
+                    : {}),
+            }),
+            ...(sessions ? { mockSignatures: sessions.mockSignatures } : {}),
+        },
+        calls,
+        sourceCalls: mergeSourceCalls(sessions?.preClaimCalls, source.calls),
+        providedFunds: source.providedFunds,
+    });
+    const response = await context.quoteClient.createQuote(request);
+    const quote = normalizeIntentQuote(selectIntentQuote(response.routes));
+    const quotes = response.routes.map((candidate) => candidate.intentId === quote.intentId
+        ? quote
+        : normalizeIntentQuote(candidate));
+    return {
+        traceId: response.traceId,
+        input,
+        request,
+        quote,
+        quotes,
+        signing: buildIntentSigningInput(runtime, quote, sessions?.byChain, input.destination.kind === 'evm' ? input.destination : undefined, ownerSelection?.validator, ownerSelection?.signerIds),
+        accountChain,
+        ...(sessions
+            ? {
+                resolvedSessions: sessions.byChain,
+                sessionEnvironment: runtime.construction.sessions.environment,
+            }
+            : {}),
+    };
+}
+function selectAccountChain(input) {
+    if (input.destination.kind === 'evm')
+        return input.destination;
+    const source = input.sourceChains?.at(-1);
+    if (!source) {
+        throw new Error('A non-EVM intent requires at least one EVM source chain');
+    }
+    return source;
+}
+async function resolveDestinationCalls(context, input, runtime) {
+    if (input.destination.kind === 'non-evm') {
+        if (input.calls.length > 0) {
+            throw new Error(`Destination calls are not supported for ${input.destination.caip2}`);
+        }
+        return [];
+    }
+    return resolveCalls(input.calls, {
+        account: runtime.identity.address,
+        chain: input.destination,
+        config: context.compatibilityConfig,
+    });
+}
+async function resolveSourceCalls(context, input, runtime) {
+    const allowed = new Map((input.sourceChains ?? []).map((chain) => [chain.id, chain]));
+    if (input.destination.kind === 'evm') {
+        allowed.set(input.destination.id, input.destination);
+    }
+    const calls = {};
+    const providedFunds = {};
+    for (const [chainIdValue, sourceCalls] of Object.entries(input.sourceCalls ?? {})) {
+        const chainId = Number(chainIdValue);
+        const chain = allowed.get(chainId);
+        if (!chain)
+            throw new Error(`Invalid source calls chain ${chainId}`);
+        calls[chainId] = await resolveCalls(sourceCalls.map(({ call }) => call), {
+            account: runtime.identity.address,
+            chain,
+            config: context.compatibilityConfig,
+        });
+        for (const sourceCall of sourceCalls) {
+            for (const provided of sourceCall.provides ?? []) {
+                const balances = (providedFunds[chainId] ??= {});
+                balances[provided.token] =
+                    (balances[provided.token] ?? 0n) + provided.amount;
+            }
+        }
+    }
+    return { calls, providedFunds };
+}
+export function buildIntentSigningInput(runtime, quote, sessions, destination, ownerValidator, selectedSignerIds) {
+    const sessionTopology = sessions
+        ? signingTopology(defineValidator(requireSession(sessions).session.owners, 'smart-session-validator'))
+        : undefined;
+    const selectedOwner = ownerValidator ?? runtime.construction.owner;
+    const topology = sessionTopology
+        ? sessionTopology
+        : selectedOwner
+            ? signingTopology(selectedOwner, selectedSignerIds)
+            : {
+                configuredTopology: {
+                    rootValidatorId: 'eoa',
+                    validators: [],
+                    threshold: 1,
+                },
+                effectiveSelection: {
+                    validatorIds: [],
+                    signerIds: runtime.construction.eoa
+                        ? [ecdsaSignerId(runtime.construction.eoa)]
+                        : [],
+                    threshold: 1,
+                },
+            };
+    const origins = quote.signData.origin.map((typedData, index) => ({
+        id: hashTypedData(typedData),
+        chain: toEvmChainReference(Number(typedData.domain?.chainId)),
+        role: 'origin',
+        typedData,
+        usage: 'intent-origin',
+        artifactId: `origin-${index}`,
+    }));
+    if (origins.length === 0)
+        throw new Error('Intent quote has no origin payloads');
+    const lastOrigin = origins.at(-1);
+    if (!lastOrigin)
+        throw new Error('Intent quote has no origin payloads');
+    const destinationChain = destination;
+    const destinationSession = destinationChain
+        ? sessions?.[destinationChain.id]
+        : undefined;
+    const destinationPayload = destinationChain
+        ? {
+            id: hashTypedData(quote.signData.destination),
+            chain: toEvmChainReference(Number(quote.signData.destination.domain?.chainId ?? destinationChain.id)),
+            role: 'destination',
+            typedData: quote.signData.destination,
+            usage: 'intent-destination',
+        }
+        : undefined;
+    const targetExecution = quote.signData.targetExecution;
+    const targetCandidate = targetExecution
+        ? {
+            id: hashTypedData(targetExecution),
+            chain: toEvmChainReference(Number(targetExecution.domain?.chainId ??
+                chainIdFromReference(runtime.construction.chain))),
+            role: 'target',
+            typedData: targetExecution,
+            usage: 'intent-target',
+        }
+        : undefined;
+    const targetSession = targetCandidate
+        ? sessions?.[targetCandidate.chain.id]
+        : undefined;
+    const target = targetCandidate && targetSession?.verifyExecutions
+        ? targetCandidate
+        : undefined;
+    return {
+        // Standalone `signIntent(SignData)` builds a synthetic quote with no
+        // intentId; fall back to the last origin payload hash so the signing-task
+        // namespace stays deterministic rather than relying on `stringToHex`
+        // coercing `undefined` to an empty string.
+        id: quote.intentId ? keccak256(stringToHex(quote.intentId)) : lastOrigin.id,
+        preparedSignatureMode: sessions
+            ? Object.values(sessions).some(({ verifyExecutions }) => verifyExecutions)
+                ? 'session-with-execution-verification'
+                : 'session'
+            : 'default',
+        ...topology,
+        origins: origins.map(({ artifactId: _artifactId, ...origin }) => origin),
+        destination: sessions && destinationSession && destinationPayload
+            ? {
+                mode: 'sign',
+                payload: destinationPayload,
+                artifactId: 'destination',
+            }
+            : {
+                mode: 'reuse-origin',
+                artifactId: 'destination',
+                originArtifactId: lastOrigin.artifactId,
+                selection: sessions ? 'pre-claim' : 'whole',
+            },
+        ...(target ? { target } : {}),
+        artifacts: [
+            ...origins.map((origin) => ({
+                id: origin.artifactId,
+                usage: 'intent-origin',
+                payloadId: origin.id,
+                cardinality: 'one',
+                shape: sessions?.[origin.chain.id]?.verifyExecutions
+                    ? 'session-claims'
+                    : 'hex',
+                exposedForIndependentSigning: !sessions,
+            })),
+            {
+                id: 'destination',
+                usage: 'intent-destination',
+                payloadId: hashTypedData(quote.signData.destination),
+                cardinality: 'one',
+                shape: 'hex',
+                exposedForIndependentSigning: false,
+            },
+            ...(target
+                ? [
+                    {
+                        id: 'target',
+                        usage: 'intent-target',
+                        payloadId: target.id,
+                        cardinality: 'one',
+                        shape: 'hex',
+                        exposedForIndependentSigning: false,
+                    },
+                ]
+                : []),
+        ],
+    };
+}
+function requireSession(sessions) {
+    const session = Object.values(sessions)[0];
+    if (!session)
+        throw new Error('Intent session selection is empty');
+    return session;
+}
+function mergeSourceCalls(first, second) {
+    const result = { ...first };
+    for (const [chainId, calls] of Object.entries(second)) {
+        result[Number(chainId)] = [...(result[Number(chainId)] ?? []), ...calls];
+    }
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import type { OrchestratorQuote } from '../../clients/orchestrator/types.js';
+export declare function selectIntentQuote(quotes: readonly OrchestratorQuote[], intentId?: string): OrchestratorQuote;
+//# sourceMappingURL=quotes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quotes.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/quotes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,iBAAiB,EAAE,EACpC,QAAQ,CAAC,EAAE,MAAM,GAChB,iBAAiB,CAYnB"}

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

@@ -0,0 +1,11 @@
+export function selectIntentQuote(quotes, intentId) {
+    const quote = intentId
+        ? quotes.find((candidate) => candidate.intentId === intentId)
+        : quotes[0];
+    if (!quote) {
+        throw new Error(intentId
+            ? `Quote ${intentId} is not in the prepared transaction`
+            : 'Orchestrator returned no quote');
+    }
+    return quote;
+}

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

@@ -0,0 +1,11 @@
+import type { Call } from '../../calls/types.js';
+import type { OrchestratorAccount, OrchestratorIntentRequest } from '../../clients/orchestrator/types.js';
+import type { IntentInput } from './types.js';
+export declare function buildIntentRequest<CompatibilityConfig>(input: {
+    readonly transaction: IntentInput<CompatibilityConfig>;
+    readonly account: OrchestratorAccount;
+    readonly calls: readonly Call[];
+    readonly sourceCalls: Readonly<Record<number, readonly Call[]>>;
+    readonly providedFunds: Readonly<Record<number, Readonly<Record<`0x${string}`, bigint>>>>;
+}): OrchestratorIntentRequest;
+//# sourceMappingURL=request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAG7C,OAAO,KAAK,EACV,mBAAmB,EAEnB,yBAAyB,EAC1B,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,wBAAgB,kBAAkB,CAAC,mBAAmB,EAAE,KAAK,EAAE;IAC7D,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,mBAAmB,CAAC,CAAA;IACtD,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IAC/B,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC,CAAA;IAC/D,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAC9B,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,MAAM,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,CACxD,CAAA;CACF,GAAG,yBAAyB,CA4C5B"}

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

@@ -0,0 +1,55 @@
+import { chainIdFromReference } from '../../chains/caip2.js';
+import { normalizeTokenAddress } from '../../chains/tokens.js';
+export function buildIntentRequest(input) {
+    const destinationChainId = chainIdFromReference(input.transaction.destination);
+    const nonEvm = input.transaction.destination.kind === 'non-evm';
+    const auxiliaryFunds = mergeAuxiliaryFunds(input.transaction.options?.auxiliaryFunds, input.providedFunds);
+    return {
+        account: input.account,
+        destinationChainId,
+        destinationExecutions: input.calls.map(toExecution),
+        tokenRequests: input.transaction.tokenRequests.map((request) => ({
+            tokenAddress: normalizeTokenAddress(request.token, destinationChainId, nonEvm),
+            ...(request.amount === undefined ? {} : { amount: request.amount }),
+        })),
+        ...(input.transaction.recipient
+            ? { recipient: input.transaction.recipient }
+            : {}),
+        ...(input.transaction.gasLimit === undefined
+            ? {}
+            : { destinationGasUnits: input.transaction.gasLimit }),
+        ...(input.transaction.accountAccessList
+            ? { accountAccessList: input.transaction.accountAccessList }
+            : {}),
+        options: {
+            ...input.transaction.options,
+            signatureMode: input.transaction.signatureMode ?? 1,
+            ...(auxiliaryFunds ? { auxiliaryFunds } : {}),
+        },
+        ...(Object.keys(input.sourceCalls).length > 0
+            ? {
+                preClaimExecutions: Object.fromEntries(Object.entries(input.sourceCalls).map(([chainId, calls]) => [
+                    Number(chainId),
+                    calls.map(toExecution),
+                ])),
+            }
+            : {}),
+    };
+}
+function toExecution(call) {
+    return { to: call.target, value: call.value, data: call.data };
+}
+function mergeAuxiliaryFunds(configured, provided) {
+    const result = {};
+    for (const [chainId, balances] of Object.entries(configured ?? {})) {
+        result[Number(chainId)] = { ...balances };
+    }
+    for (const [chainId, balances] of Object.entries(provided)) {
+        const target = (result[Number(chainId)] ??= {});
+        for (const [token, amount] of Object.entries(balances)) {
+            target[token] =
+                (target[token] ?? 0n) + amount;
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/send.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,WAAW,EACX,qBAAqB,EACrB,eAAe,EAChB,MAAM,SAAS,CAAA;AAEhB,wBAAsB,UAAU,CAAC,mBAAmB,EAClD,OAAO,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,EACnD,KAAK,EAAE,WAAW,CAAC,mBAAmB,CAAC,GACtC,OAAO,CAAC,eAAe,CAAC,CAa1B"}

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

@@ -0,0 +1,22 @@
+import { prepareIntent } from './prepare.js';
+import { signIntent } from './sign-transaction.js';
+import { submitIntent } from './submit.js';
+export async function sendIntent(context, input) {
+    const prepared = await prepareIntent(context, input);
+    let signed = await signIntent(context, prepared);
+    if (input.eip7702InitSignature) {
+        signed = {
+            ...signed,
+            authorizations: await context.signAuthorizations({
+                chains: authorizationChains(input),
+                eip7702InitSignature: input.eip7702InitSignature,
+            }),
+        };
+    }
+    return submitIntent(context, signed);
+}
+function authorizationChains(input) {
+    const chains = new Map((input.sourceChains ?? []).map((chain) => [chain.caip2, chain]));
+    chains.set(input.destination.caip2, input.destination);
+    return [...chains.values()];
+}

package/dist/src/transactions/intents/session-signing.d.ts

@@ -0,0 +1,7 @@
+import type { SigningContext } from '../../signing/context.js';
+import type { IntentSigningPlanCreationInput } from '../../signing/intent-plans/types.js';
+import type { SignerInvocationPort } from '../../signing/types.js';
+import type { PreparedIntent } from './types.js';
+export declare function createIntentSessionSignerInvoker<CompatibilityConfig>(prepared: PreparedIntent<CompatibilityConfig>, fallback: SignerInvocationPort): SignerInvocationPort;
+export declare function buildSessionIntentPlanInput<CompatibilityConfig>(prepared: PreparedIntent<CompatibilityConfig>, context: SigningContext): IntentSigningPlanCreationInput;
+//# sourceMappingURL=session-signing.d.ts.map

package/dist/src/transactions/intents/session-signing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-signing.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/session-signing.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAE3D,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAA;AAOtF,OAAO,KAAK,EAEV,oBAAoB,EAGrB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,wBAAgB,gCAAgC,CAAC,mBAAmB,EAClE,QAAQ,EAAE,cAAc,CAAC,mBAAmB,CAAC,EAC7C,QAAQ,EAAE,oBAAoB,GAC7B,oBAAoB,CA+BtB;AAED,wBAAgB,2BAA2B,CAAC,mBAAmB,EAC7D,QAAQ,EAAE,cAAc,CAAC,mBAAmB,CAAC,EAC7C,OAAO,EAAE,cAAc,GACtB,8BAA8B,CA2FhC"}