otto-intel-mcp 0.1.2 → 0.1.4

package/dist/execution-sponsored-definition.js

@@ -0,0 +1,185 @@
+import { ACCOUNT_GAS_FAILURE_SCHEMA } from './execution-account-gas-view.js';
+import { ACCOUNT_GAS_REVIEW_SCHEMA } from './execution-account-gas-review.js';
+import { SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA } from './account-userop-policy-definition.js';
+import { createHash } from 'node:crypto';
+import { encodeFunctionData, getAddress, parseAbi } from 'viem';
+import { z } from 'zod';
+import { EXECUTION_ARTIFACT_SCHEMA } from './execution-index.js';
+import { defaultAdapterPolicy, verifySwapEnvelope } from './adapter/verify.js';
+export const SPONSORED_CHAIN_SCHEMA = z.union([z.literal(1), z.literal(8453), z.literal(42161), z.literal(10), z.literal(137)]);
+const address = z.string().regex(/^0x[0-9a-fA-F]{40}$/).transform((value, context) => {
+    try {
+        return getAddress(value);
+    }
+    catch {
+        context.addIssue({ code: 'custom', message: 'Invalid account address' });
+        return z.NEVER;
+    }
+});
+const erc20OutputAddress = address.refine(value => ![
+    '0x0000000000000000000000000000000000000000',
+    '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+].includes(value.toLowerCase()), 'Sponsored swaps require ERC20 output; native currency output is unsupported');
+const hash = z.string().regex(/^0x[0-9a-fA-F]{64}$/);
+const digest = z.string().regex(/^[0-9a-f]{64}$/);
+const atomic = z.string().regex(/^(0|[1-9][0-9]*)$/).refine(v => /^(0|[1-9][0-9]*)$/.test(v) && BigInt(v) < 2n ** 256n);
+const positiveAtomic = atomic.refine(v => /^(0|[1-9][0-9]*)$/.test(v) && BigInt(v) > 0n);
+const time = z.number().int().positive().safe();
+export const SPONSORED_USDC = Object.freeze({
+    1: getAddress('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
+    8453: getAddress('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'),
+    42161: getAddress('0xaf88d065e77c8cC2239327C5EDb3A432268e5831'),
+    10: getAddress('0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85'),
+    137: getAddress('0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359'),
+});
+/** Source-reviewed same-address account profile; ownership is derived from the authenticated account. */
+export const SPONSORED_NATIVE_USEROP_PROFILE_SCHEMA = z.object({
+    implementation: address, implementationCodeHash: hash,
+    delegateBatchAbi: z.literal('coinbase-executeBatch-v1'), delegateBatchReviewDigest: digest,
+    entryPointVersion: z.literal('0.6'),
+    ownerProfile: z.object({ kind: z.literal('sole-eoa-owner'), nextOwnerIndex: z.literal('1'),
+        ownerCount: z.literal('1'), requireAccountAsOwner: z.literal(true), spendPermissionsEnabled: z.literal(false) }).strict(),
+}).strict();
+export const SPONSORED_NATIVE_USEROP_POLICY_RELATION_SCHEMA = z.object({
+    nativeActivationCommitment: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+    nativeRulesDigest: digest, compiledFullPolicyDigest: digest, relationReviewEvidenceDigest: digest,
+    compiler: z.literal('legacy-v2-native-enduser-userop-v1'),
+}).strict();
+export const SPONSORED_CHAIN_TERMS_SCHEMA = z.object({
+    chainId: SPONSORED_CHAIN_SCHEMA,
+    delegate: address, delegateCodeHash: hash,
+    nativeYieldUserOpProfile: SPONSORED_NATIVE_USEROP_PROFILE_SCHEMA.optional(),
+    entryPoint: address, entryPointCodeHash: hash,
+    paymaster: address, paymasterCodeHash: hash,
+    /** Reviewed standard ERC20 semantics are required for transfer-event settlement. */
+    reviewedOutputTokens: z.array(z.object({ address: erc20OutputAddress, codeHash: hash,
+        reviewEvidenceDigest: digest }).strict()).min(1).max(32)
+        .refine(tokens => new Set(tokens.map(token => token.address)).size === tokens.length),
+    sponsorshipPolicyId: z.string().regex(/^[a-zA-Z0-9_-]{1,128}$/),
+    /** Source-reviewed feed for advisory gas-price display; the provider enforces the USD subsidy cap. */
+    nativeGasUsdFeed: z.object({ address, decimals: z.number().int().min(0).max(18),
+        maxAgeSeconds: z.number().int().min(1).max(86400) }).strict().optional(),
+    maxGasCostWei: positiveAtomic, maxTotalGasCostWei: positiveAtomic, maxUserGasCostWei: positiveAtomic,
+}).strict().refine(v => BigInt(v.maxGasCostWei) <= BigInt(v.maxUserGasCostWei) &&
+    BigInt(v.maxUserGasCostWei) <= BigInt(v.maxTotalGasCostWei), 'Sponsorship budgets must contain the per-operation reservation');
+export const SPONSORED_ACTIVATION_SCHEMA = z.object({
+    version: z.literal(1), id: z.string().regex(/^[a-zA-Z0-9_-]{8,100}$/),
+    mode: z.enum(['enabled', 'recovery-only']),
+    projectId: z.string().uuid(), policyId: z.string().min(1).max(200), policyName: z.string().min(1).max(50),
+    policyRulesDigest: digest,
+    /** Exact reviewed evidence for the end-user UserOp policy and provider's global/per-user/per-op limits. */
+    providerEnforcementEvidenceDigest: digest,
+    nativeYieldUserOpPolicyRelation: SPONSORED_NATIVE_USEROP_POLICY_RELATION_SCHEMA.optional(),
+    lpUserOpPolicyRelation: SPONSORED_LP_USEROP_POLICY_RELATION_SCHEMA.optional(),
+    approvedAtMs: time, expiresAtMs: time,
+    maxSwapUsdc: z.number().int().min(1).max(5000),
+    /** Enables explicit payer reviews with estimated user-paid gas; no new wallet authority. */
+    gasPaymentReviewEnabled: z.literal(true).optional(),
+    /** A balance snapshot admits only these designated test accounts; it is not a guaranteed fee cap. */
+    userPaidGasPilot: z.array(z.object({ account: address, chainId: SPONSORED_CHAIN_SCHEMA,
+        maximumObservedExposureWei: positiveAtomic }).strict()).min(1).max(10).optional(),
+    chains: z.array(SPONSORED_CHAIN_TERMS_SCHEMA).min(1).max(5),
+}).strict().refine(v => v.expiresAtMs > v.approvedAtMs && new Set(v.chains.map(c => c.chainId)).size === v.chains.length);
+/** Source-reviewed activation only. No environment toggle or caller-supplied approval can populate this. */
+export const SPONSORED_ACCOUNT_ACTIVATIONS = Object.freeze([]);
+/** A native-only compiler grants no swap authority. Additional combined policy compilers require source review. */
+export function sponsoredActivationSupports(activation, capability) {
+    if (capability === 'lp-collect-userop')
+        return !!activation.nativeYieldUserOpPolicyRelation && !!activation.lpUserOpPolicyRelation;
+    if (capability === 'native-yield-userop')
+        return !!activation.nativeYieldUserOpPolicyRelation;
+    return !activation.nativeYieldUserOpPolicyRelation && !activation.lpUserOpPolicyRelation;
+}
+export function sponsoredActivationAvailability(activations, nowMs, capability = 'swap') {
+    const activation = activations.length === 1 ? activations[0] : undefined;
+    const current = !!activation && Number.isSafeInteger(nowMs) &&
+        activation.approvedAtMs <= nowMs && activation.expiresAtMs > nowMs;
+    const supports = !!activation && sponsoredActivationSupports(activation, capability);
+    return { configured: !!activation, executionEnabled: current && supports && activation.mode === 'enabled',
+        ...(!activation ? { reason: 'SPONSOR_ACTIVATION_UNCONFIGURED' }
+            : !supports ? { reason: 'SPONSOR_CAPABILITY_UNAVAILABLE' }
+                : !current ? { reason: 'SPONSOR_ACTIVATION_UNAVAILABLE' }
+                    : activation.mode !== 'enabled' ? { reason: 'SPONSOR_RECOVERY_ONLY' } : {}) };
+}
+export const SPONSORED_INTENT_SCHEMA = z.object({ fromToken: address, toToken: erc20OutputAddress,
+    fromAmount: positiveAtomic, minAmountOut: positiveAtomic }).strict();
+export const SPONSORED_PREPARE_INPUT = z.object({ accessToken: z.string().min(1).max(16384), account: address,
+    chainId: SPONSORED_CHAIN_SCHEMA, envelope: EXECUTION_ARTIFACT_SCHEMA, intent: SPONSORED_INTENT_SCHEMA,
+    prepareInput: z.unknown().optional() }).strict();
+export const SPONSORED_READ_INPUT = z.object({ accessToken: z.string().min(1).max(16384),
+    operationId: z.string().regex(/^sp_[a-f0-9-]{36}$/) }).strict();
+export const SPONSORED_GAS_REVIEW_INPUT = SPONSORED_READ_INPUT.extend({ reviewCommitment: digest,
+    preference: z.enum(['auto', 'sponsor', 'account']) }).strict();
+export const SPONSORED_SUBMIT_INPUT = SPONSORED_READ_INPUT.extend({ reviewCommitment: digest }).strict();
+export const SPONSORED_AUTHORITY_SCHEMA = z.object({ userId: z.string().regex(/^[a-zA-Z0-9-]{1,100}$/),
+    account: address, mintKey: z.string().min(1).max(200), grantExpiresAt: z.string().datetime(),
+    revokeGeneration: z.number().int().nonnegative().safe(), capVersion: z.literal(2),
+    perSwapCapUsd: z.number().int().min(1).max(5000), activationDigest: digest, policyRulesDigest: digest,
+}).strict();
+export const SPONSORED_CONTEXT_SCHEMA = z.object({
+    account: address, chainId: SPONSORED_CHAIN_SCHEMA, envelope: EXECUTION_ARTIFACT_SCHEMA,
+    intent: SPONSORED_INTENT_SCHEMA, prepareInput: z.unknown().optional(),
+    authority: SPONSORED_AUTHORITY_SCHEMA, activation: SPONSORED_ACTIVATION_SCHEMA,
+    reviewedAtMs: time, validUntilMs: time,
+}).strict();
+export const SPONSORED_STORED_REQUEST_SCHEMA = z.object({
+    userId: z.string().regex(/^[a-zA-Z0-9-]{1,100}$/), account: address, chainId: SPONSORED_CHAIN_SCHEMA,
+    idempotencyKey: z.string().uuid(), path: z.string().min(1).max(400), body: z.string().max(1_000_000), digest,
+}).strict();
+export const SPONSORED_RECEIPT_SCHEMA = z.object({ chainId: SPONSORED_CHAIN_SCHEMA, account: address,
+    userOpHash: hash, transactionHash: hash, blockHash: hash, blockNumber: atomic, nonce: atomic,
+    paymaster: address, actualGasCostWei: positiveAtomic, actualGasUsed: positiveAtomic,
+    status: z.enum(['success', 'reverted']) }).strict();
+export const SPONSORED_SETTLEMENT_SCHEMA = z.object({ inputToken: address, outputToken: address,
+    inputDebited: positiveAtomic, outputReceived: positiveAtomic, ottoFeeReceived: atomic,
+    allowanceAfter: z.literal('0'), userOpHash: hash, transactionHash: hash,
+}).strict();
+export const SPONSORED_OPERATION_SCHEMA = z.object({ version: z.literal(1),
+    operationId: z.string().regex(/^sp_[a-f0-9-]{36}$/), userId: z.string().regex(/^[a-zA-Z0-9-]{1,100}$/),
+    context: SPONSORED_CONTEXT_SCHEMA, gasReview: ACCOUNT_GAS_REVIEW_SCHEMA.optional(), gasReviewFailure: ACCOUNT_GAS_FAILURE_SCHEMA.optional(), reviewCommitment: digest, reviewConsumed: z.boolean(),
+    state: z.enum(['review', 'active', 'unknown', 'submitted', 'completed', 'failed']),
+    createdAtMs: time, updatedAtMs: time, handoffAttempted: z.boolean(),
+    request: SPONSORED_STORED_REQUEST_SCHEMA.optional(), userOpHash: hash.optional(), transactionHash: hash.optional(),
+    receipt: SPONSORED_RECEIPT_SCHEMA.optional(), settlement: SPONSORED_SETTLEMENT_SCHEMA.optional(),
+    /** A proven provider cap breach stops the whole activation/chain; it is not terminal settlement. */
+    gasCapBreach: SPONSORED_RECEIPT_SCHEMA.optional(),
+    failureCode: z.string().regex(/^[A-Z0-9_]{1,100}$/).optional(),
+}).strict();
+export function sponsoredDigest(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+export function sponsoredReviewCommitment(operationId, context, gasReview) {
+    if (gasReview)
+        return sponsoredDigest({ domain: 'otto-account-gas-review-v1', operationId, context, gasReview });
+    return sponsoredDigest({ domain: 'otto-sponsored-review-v1', operationId, context });
+}
+export function sponsoredPlan(context, fresh = false, nowMs = Date.now()) {
+    if (!sponsoredActivationSupports(context.activation, 'swap'))
+        throw new Error('SPONSOR_CAPABILITY_UNAVAILABLE');
+    sponsoredOutputToken(context.activation, context.chainId, context.intent.toToken);
+    return verifySwapEnvelope(context.envelope, {
+        profile: { kind: 'eoa', address: context.account, chainId: context.chainId },
+        intent: { ...context.intent, fromAmount: BigInt(context.intent.fromAmount), minAmountOut: BigInt(context.intent.minAmountOut) },
+        capabilities: ['send_evm_transaction', 'submit_evm_batch'], policy: defaultAdapterPolicy(context.chainId),
+        nowMs: fresh ? nowMs : context.reviewedAtMs, ...(context.prepareInput !== undefined ? { prepareInput: context.prepareInput } : {}),
+    });
+}
+export function sponsoredCalls(plan) {
+    return [...plan.steps.map(step => ({ to: step.to.toLowerCase(), data: step.data.toLowerCase(), value: step.value.toString() })),
+        { to: plan.token.toLowerCase(), data: encodeFunctionData({
+                abi: parseAbi(['function approve(address spender,uint256 value) returns(bool)']), functionName: 'approve', args: [plan.spender, 0n],
+            }).toLowerCase(), value: '0' }];
+}
+export function sponsoredChainTerms(activation, chainId) {
+    const terms = activation.chains.find(c => c.chainId === chainId);
+    if (!terms)
+        throw new Error('SPONSOR_CHAIN_UNAVAILABLE');
+    return terms;
+}
+export function sponsoredOutputToken(activation, chainId, token) {
+    const reviewed = sponsoredChainTerms(activation, chainId).reviewedOutputTokens.find(output => output.address === getAddress(token));
+    if (!reviewed)
+        throw new Error('SPONSOR_OUTPUT_TOKEN_UNREVIEWED');
+    return reviewed;
+}
+//# sourceMappingURL=execution-sponsored-definition.js.map

package/dist/execution-sponsored-gas-policy.d.ts

@@ -0,0 +1,27 @@
+export declare const SPONSORED_INITIAL_GAS_CAP_USD_MICROS = 100000;
+export declare const SPONSORED_GAS_POLICY_MAX_AGE_MS = 15000;
+export type SponsoredGasPolicyErrorCode = 'SPONSOR_GAS_POLICY_UNAVAILABLE' | 'SPONSOR_GAS_POLICY_INVALID' | 'SPONSOR_GAS_POLICY_INACTIVE' | 'SPONSOR_GAS_POLICY_STALE';
+export declare class SponsoredGasPolicyError extends Error {
+    readonly code: SponsoredGasPolicyErrorCode;
+    constructor(code: SponsoredGasPolicyErrorCode);
+}
+export interface SponsoredGasPolicyProvider {
+    readonly chainId: number;
+    readonly paymasterUrl: string;
+    readonly sponsorshipPolicyId: string;
+}
+/** Safe to expose or record: contains no endpoint, API key or upstream response body. */
+export interface SponsoredGasPolicyProof {
+    readonly chainId: number;
+    readonly sponsorshipPolicyId: string;
+    readonly maximumGasCostUsdMicros: number;
+    /** Freshness starts before the read, so request latency cannot extend its lifetime. */
+    readonly checkedAtMs: number;
+    readonly validUntilMs: number;
+}
+export declare function assertSponsoredGasPolicyCurrent(proof: SponsoredGasPolicyProof, nowMs: number): void;
+export declare function readSponsoredGasPolicy(provider: SponsoredGasPolicyProvider, options?: {
+    readonly fetch?: typeof fetch;
+    readonly now?: () => number;
+    readonly monotonic?: () => number;
+}): Promise<Readonly<SponsoredGasPolicyProof>>;

package/dist/execution-sponsored-gas-policy.js

@@ -0,0 +1,110 @@
+/** Provider-enforced initial network-gas policy. Third-party service charges are separate.
+ * A readback is fresh configuration evidence, not an immutable provider authorization.
+ */
+import { z } from 'zod';
+export const SPONSORED_INITIAL_GAS_CAP_USD_MICROS = 100_000;
+export const SPONSORED_GAS_POLICY_MAX_AGE_MS = 15_000;
+const POLICY_TIMEOUT_MS = 10_000;
+const policyId = z.string().regex(/^[a-zA-Z0-9_-]{1,128}$/);
+const timestamp = z.string().datetime({ offset: true });
+const policySchema = z.object({
+    id: policyId,
+    policy_status: z.enum(['active', 'inactive', 'deleted']),
+    start_time: timestamp.nullable(),
+    end_time: timestamp.nullable(),
+    chain_ids: z.object({ allowlist: z.array(z.number().int().positive().safe()).length(1) }),
+    limits: z.object({ user_operation: z.object({ user_operation_spending: z.object({
+                amount: z.number().int().min(1).max(SPONSORED_INITIAL_GAS_CAP_USD_MICROS / 10_000), currency: z.literal('USD'),
+            }) }) }),
+});
+export class SponsoredGasPolicyError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'SponsoredGasPolicyError';
+    }
+}
+const proofClocks = new WeakMap();
+function effectiveTime(clock, wallMs) {
+    const elapsed = clock.monotonic() - clock.startMonotonicMs;
+    if (!Number.isSafeInteger(wallMs) || wallMs < clock.startWallMs || !Number.isFinite(elapsed) || elapsed < 0)
+        return refuse('SPONSOR_GAS_POLICY_STALE');
+    return Math.max(wallMs, clock.startWallMs + Math.ceil(elapsed));
+}
+function refuse(code) { throw new SponsoredGasPolicyError(code); }
+function policyReadUrl(provider) {
+    try {
+        if (!Number.isSafeInteger(provider.chainId) || provider.chainId <= 0)
+            throw new Error();
+        policyId.parse(provider.sponsorshipPolicyId);
+        const rpc = new URL(provider.paymasterUrl);
+        if (rpc.protocol !== 'https:' || rpc.hostname !== 'api.pimlico.io' || rpc.port || rpc.username || rpc.password || rpc.hash ||
+            rpc.pathname !== `/v2/${provider.chainId}/rpc` || [...rpc.searchParams.keys()].length !== 1 || !rpc.searchParams.get('apikey'))
+            throw new Error();
+        const url = new URL(`https://api.pimlico.io/v2/account/sponsorship_policies/${provider.sponsorshipPolicyId}`);
+        url.searchParams.set('apikey', rpc.searchParams.get('apikey'));
+        return url.toString();
+    }
+    catch {
+        return refuse('SPONSOR_GAS_POLICY_INVALID');
+    }
+}
+export function assertSponsoredGasPolicyCurrent(proof, nowMs) {
+    const clock = proofClocks.get(proof);
+    if (!clock)
+        return refuse('SPONSOR_GAS_POLICY_STALE');
+    nowMs = effectiveTime(clock, nowMs);
+    if (!Number.isSafeInteger(nowMs) || !Number.isSafeInteger(proof.checkedAtMs) || !Number.isSafeInteger(proof.validUntilMs) ||
+        nowMs < proof.checkedAtMs || nowMs >= proof.validUntilMs ||
+        proof.validUntilMs > proof.checkedAtMs + SPONSORED_GAS_POLICY_MAX_AGE_MS)
+        refuse('SPONSOR_GAS_POLICY_STALE');
+}
+export async function readSponsoredGasPolicy(provider, options = {}) {
+    provider = Object.freeze({ ...provider });
+    const url = policyReadUrl(provider), now = options.now ?? Date.now;
+    const monotonic = options.monotonic ?? (() => performance.now()), startMonotonicMs = monotonic();
+    const checkedAtMs = now();
+    if (!Number.isSafeInteger(checkedAtMs) || checkedAtMs < 0 || !Number.isFinite(startMonotonicMs) || startMonotonicMs < 0)
+        return refuse('SPONSOR_GAS_POLICY_STALE');
+    const clock = { startWallMs: checkedAtMs, startMonotonicMs, monotonic };
+    let raw;
+    try {
+        const response = await (options.fetch ?? fetch)(url, { method: 'GET', redirect: 'error',
+            signal: AbortSignal.timeout(POLICY_TIMEOUT_MS), headers: { Accept: 'application/json' } });
+        if (!response.ok)
+            return refuse('SPONSOR_GAS_POLICY_UNAVAILABLE');
+        const body = await response.text();
+        if (body.length > 65_536)
+            return refuse('SPONSOR_GAS_POLICY_INVALID');
+        try {
+            raw = JSON.parse(body);
+        }
+        catch {
+            return refuse('SPONSOR_GAS_POLICY_INVALID');
+        }
+    }
+    catch (error) {
+        if (error instanceof SponsoredGasPolicyError)
+            throw error;
+        return refuse('SPONSOR_GAS_POLICY_UNAVAILABLE');
+    }
+    const parsed = policySchema.safeParse(raw);
+    if (!parsed.success)
+        return refuse('SPONSOR_GAS_POLICY_INVALID');
+    const policy = parsed.data;
+    if (policy.id !== provider.sponsorshipPolicyId || policy.chain_ids.allowlist[0] !== provider.chainId)
+        return refuse('SPONSOR_GAS_POLICY_INVALID');
+    const currentMs = effectiveTime(clock, now()), startsAt = policy.start_time === null ? null : Date.parse(policy.start_time);
+    const endsAt = policy.end_time === null ? null : Date.parse(policy.end_time);
+    if (policy.policy_status !== 'active' || (startsAt !== null && startsAt > currentMs) ||
+        (endsAt !== null && endsAt <= currentMs) || (startsAt !== null && endsAt !== null && endsAt <= startsAt))
+        return refuse('SPONSOR_GAS_POLICY_INACTIVE');
+    const proof = Object.freeze({ chainId: provider.chainId, sponsorshipPolicyId: provider.sponsorshipPolicyId,
+        maximumGasCostUsdMicros: policy.limits.user_operation.user_operation_spending.amount * 10_000,
+        checkedAtMs, validUntilMs: Math.min(checkedAtMs + SPONSORED_GAS_POLICY_MAX_AGE_MS, endsAt ?? Number.MAX_SAFE_INTEGER) });
+    proofClocks.set(proof, clock);
+    assertSponsoredGasPolicyCurrent(proof, now());
+    return proof;
+}
+//# sourceMappingURL=execution-sponsored-gas-policy.js.map

package/dist/execution-sponsored-hosted.d.ts

@@ -0,0 +1,3 @@
+import { type DelegationServices } from './execution-delegation.js';
+import { type SponsoredAccountBinding } from './execution-sponsored-registration.js';
+export declare function createHostedSponsoredAccountBinding(env: NodeJS.ProcessEnv, delegation: DelegationServices): Promise<SponsoredAccountBinding>;

package/dist/execution-sponsored-hosted.js

@@ -0,0 +1,71 @@
+import { loadDelegationEnv } from './execution-delegation.js';
+import { resolveDelegationCapStorePath } from './execution-delegation-cap-store.js';
+import { SPONSORED_ACCOUNT_ACTIVATIONS, SPONSORED_ACTIVATION_SCHEMA } from './execution-sponsored-definition.js';
+import { createSponsoredAccountService } from './execution-sponsored-index.js';
+import { unavailableSponsoredBinding } from './execution-sponsored-registration.js';
+import { SPONSORED_AVAILABILITY_RESULT } from './execution-sponsored-mcp-definition.js';
+const RPC_ENV = Object.freeze({
+    1: 'OTTO_SPONSORED_RPC_URL_1', 8453: 'BASE_RPC_URL', 42161: 'OTTO_SPONSORED_RPC_URL_42161',
+    10: 'OTTO_SPONSORED_RPC_URL_10', 137: 'OTTO_SPONSORED_RPC_URL_137',
+});
+function privateHttpsUrl(raw) {
+    if (!raw)
+        throw new Error('missing operator endpoint');
+    const url = new URL(raw);
+    if (url.protocol !== 'https:' || url.username || url.password || url.hash)
+        throw new Error('invalid operator endpoint');
+    return url.toString();
+}
+export async function createHostedSponsoredAccountBinding(env, delegation) {
+    // This is not an environment toggle. Adding endpoints cannot authorize a new financial rail.
+    if (SPONSORED_ACCOUNT_ACTIVATIONS.length !== 1)
+        return unavailableSponsoredBinding();
+    try {
+        const activation = SPONSORED_ACTIVATION_SCHEMA.parse(SPONSORED_ACCOUNT_ACTIVATIONS[0]);
+        const loaded = loadDelegationEnv(env);
+        if (!loaded || loaded.publicProjectId !== activation.projectId ||
+            delegation.publicProjectId !== activation.projectId)
+            return unavailableSponsoredBinding('SPONSOR_ACTIVATION_UNAVAILABLE');
+        const operationStorePath = resolveDelegationCapStorePath(env);
+        if (!operationStorePath)
+            return unavailableSponsoredBinding('SPONSOR_JOURNAL_UNAVAILABLE');
+        const providers = [];
+        const urls = new Map();
+        for (const terms of activation.chains) {
+            try {
+                providers.push({ chainId: terms.chainId, sponsorshipPolicyId: terms.sponsorshipPolicyId,
+                    paymasterUrl: privateHttpsUrl(env['OTTO_SPONSORED_PAYMASTER_URL_' + terms.chainId]) });
+            }
+            catch { /* Missing send configuration leaves recovery available. */ }
+            try {
+                urls.set(terms.chainId, privateHttpsUrl(env[RPC_ENV[terms.chainId]]));
+            }
+            catch { /* Read works without RPC; reconcile keeps the original evidence until this chain returns. */ }
+        }
+        const [{ CdpClient }, { createPublicClient, http }, chains] = await Promise.all([
+            import('@coinbase/cdp-sdk'), import('viem'), import('viem/chains'),
+        ]);
+        const definitions = { 1: chains.mainnet, 8453: chains.base, 42161: chains.arbitrum,
+            10: chains.optimism, 137: chains.polygon };
+        const clients = {};
+        for (const terms of activation.chains) {
+            if (terms.chainId === 8453 && delegation.pub)
+                clients[terms.chainId] = delegation.pub;
+            else if (urls.has(terms.chainId))
+                clients[terms.chainId] = createPublicClient({
+                    chain: definitions[terms.chainId], transport: http(urls.get(terms.chainId))
+                });
+        }
+        const service = await createSponsoredAccountService({
+            cdp: new CdpClient(loaded.credentials), capStore: delegation.capStore,
+            projectId: activation.projectId, operationStorePath, clients, providers, credentials: loaded.credentials,
+        });
+        return Object.freeze({ ...service, availability: async () => SPONSORED_AVAILABILITY_RESULT.parse(await service.availability()) });
+    }
+    catch {
+        // Misconfigured sponsorship must not disable existing reads, Stop or recovery on other rails.
+        // Errors from providers may contain credentials; expose only a fixed status.
+        return unavailableSponsoredBinding('SPONSOR_RUNTIME_UNAVAILABLE');
+    }
+}
+//# sourceMappingURL=execution-sponsored-hosted.js.map