otto-intel-mcp 0.1.2 → 0.1.4

package/dist/execution-sponsored-index.js

@@ -0,0 +1,102 @@
+import { accountGasFailure } from './execution-account-gas-view.js';
+import { AccountGasPaymentRuntime } from './execution-account-gas-runtime.js';
+import { openExecutionWorkerGuardStore } from './execution-worker-guard.js';
+import { SPONSORED_ACCOUNT_ACTIVATIONS, SPONSORED_ACTIVATION_SCHEMA, sponsoredActivationAvailability } from './execution-sponsored-definition.js';
+import { createSponsoredCdpTransport } from './execution-sponsored-transport.js';
+import { SponsoredAccountRuntime, SponsoredAccountRefusal } from './execution-sponsored-runtime.js';
+import { openSponsoredOperationStore } from './execution-sponsored-store.js';
+import { SponsoredAccountService } from './execution-sponsored-account.js';
+export function sponsoredAccountAvailability() {
+    return Object.freeze({ schemaVersion: '1',
+        ...sponsoredActivationAvailability(SPONSORED_ACCOUNT_ACTIVATIONS, Date.now()),
+        requiresSeparateWalletUpgrade: true, requiresOperationReview: true,
+        automaticExecutionEnabled: false,
+        supportedSameAddressChains: SPONSORED_ACCOUNT_ACTIVATIONS.length === 1
+            ? SPONSORED_ACCOUNT_ACTIVATIONS[0].chains.map(terms => terms.chainId) : [] });
+}
+export async function createSponsoredAccountService(options) {
+    if (SPONSORED_ACCOUNT_ACTIVATIONS.length !== 1)
+        throw new SponsoredAccountRefusal('SPONSOR_ACTIVATION_UNCONFIGURED');
+    const activation = SPONSORED_ACTIVATION_SCHEMA.parse(SPONSORED_ACCOUNT_ACTIVATIONS[0]);
+    if (activation.projectId !== options.projectId)
+        throw new SponsoredAccountRefusal('SPONSOR_ACTIVATION_UNAVAILABLE');
+    if (!options.operationStorePath)
+        throw new SponsoredAccountRefusal('SPONSOR_JOURNAL_UNAVAILABLE');
+    // A send-only provider failure must not remove authenticated journal reads or receipt recovery.
+    let sendConfigurationReady = options.providers.length === activation.chains.length &&
+        activation.chains.every(terms => {
+            const matches = options.providers.filter(provider => provider.chainId === terms.chainId);
+            return matches.length === 1 && matches[0].sponsorshipPolicyId === terms.sponsorshipPolicyId;
+        });
+    let transport;
+    try {
+        transport = createSponsoredCdpTransport({ providers: options.providers, credentials: options.credentials });
+    }
+    catch {
+        sendConfigurationReady = false;
+        transport = createSponsoredCdpTransport({ providers: [], credentials: options.credentials });
+    }
+    const store = await openSponsoredOperationStore(options.operationStorePath);
+    const guards = await openExecutionWorkerGuardStore(options.operationStorePath);
+    if (!guards.available)
+        throw new SponsoredAccountRefusal('SPONSOR_JOURNAL_UNAVAILABLE');
+    const service = new SponsoredAccountService(new SponsoredAccountRuntime(options.cdp, options.capStore, options.clients, options.projectId), store, guards, transport, [activation], new AccountGasPaymentRuntime(options.clients, options.providers, transport));
+    async function invoke(work) {
+        try {
+            return await work();
+        }
+        catch (error) {
+            // CDP/RPC errors may contain request headers or provider URLs. Public callers receive codes only.
+            if (error instanceof SponsoredAccountRefusal)
+                throw error;
+            throw new SponsoredAccountRefusal(accountGasFailure(error) ?? 'SPONSOR_REQUEST_REFUSED');
+        }
+    }
+    async function availability() {
+        const source = sponsoredAccountAvailability();
+        try {
+            const journal = store.journalStatus();
+            let reason = 'reason' in source ? source.reason : undefined;
+            if (!reason && !options.capStore.available)
+                reason = 'SPONSOR_CAP_UNAVAILABLE';
+            if (!reason && (!journal.ready || !journal.sponsoredReady))
+                reason = 'SPONSOR_JOURNAL_UNAVAILABLE';
+            if (!reason && !sendConfigurationReady)
+                reason = 'SPONSOR_RUNTIME_UNAVAILABLE';
+            if (!reason) {
+                for (const terms of activation.chains) {
+                    try {
+                        if (await options.clients[terms.chainId]?.getChainId() !== terms.chainId)
+                            throw new Error('chain mismatch');
+                    }
+                    catch {
+                        reason = 'SPONSOR_CHAIN_UNAVAILABLE';
+                        break;
+                    }
+                }
+            }
+            return { ...source, executionEnabled: source.executionEnabled && !reason,
+                recoveryAvailable: true, ...(reason ? { reason } : {}) };
+        }
+        catch {
+            return { ...source, executionEnabled: false, recoveryAvailable: false,
+                reason: 'SPONSOR_JOURNAL_UNAVAILABLE' };
+        }
+    }
+    async function send(work) {
+        const current = await availability();
+        if (!current.executionEnabled)
+            throw new SponsoredAccountRefusal(current.reason ?? 'SPONSOR_RUNTIME_UNAVAILABLE');
+        return invoke(work);
+    }
+    return Object.freeze({
+        availability,
+        reviewGas: (input) => send(() => service.reviewGas(input)),
+        prepare: (input) => send(() => service.prepare(input)),
+        submit: (input) => send(() => service.submit(input)),
+        read: (input) => invoke(() => service.read(input)),
+        reconcile: (input) => invoke(() => service.reconcile(input)),
+    });
+}
+export { SPONSORED_PREPARE_INPUT, SPONSORED_READ_INPUT, SPONSORED_SUBMIT_INPUT, SPONSORED_GAS_REVIEW_INPUT } from './execution-sponsored-definition.js';
+//# sourceMappingURL=execution-sponsored-index.js.map