otto-intel-mcp 0.1.2 → 0.1.4

package/dist/lp-userop-account.js

@@ -0,0 +1,417 @@
+import { LP_USEROP_ACCOUNT_GAS_CONFIRMATION } from './lp-userop-definition.js';
+import { SPONSORED_GAS_REVIEW_INPUT } from './execution-sponsored-definition.js';
+import { accountGasBudgetPublicSchema, accountGasView, accountGasViewMatches, accountGasFailure, AccountGasConfirmationRefusal } from './execution-account-gas-view.js';
+/** One manually reviewed guarded collection on the shared sponsored execution rail. */
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { freezeHybridValue, hybridYieldCommitment } from './hybrid-yield-markets.js';
+import { LP_USEROP_CONFIRMATION, LP_USEROP_INPUT_SCHEMA } from './lp-userop-definition.js';
+import { assertFreshVerifiedLpUserOp, assertLpUserOpEnvelope, lpUserOpCalls, lpUserOpRecordedCalls, lpUserOpVerificationEvidence, prepareLpUserOp, verifyLpUserOp, simulateLpUserOp, } from './lp-userop.js';
+import { readLpUserOpSettlement, LP_USEROP_SETTLEMENT_SCHEMA } from './lp-userop-settlement.js';
+import { assertLpUserOpContext, LP_USEROP_CONTEXT_SCHEMA, } from './lp-userop-operation.js';
+import { readConfirmedSponsoredReceipt, SponsoredReceiptUnconfirmedError, } from './execution-sponsored-receipt.js';
+const token = z.string().min(1).max(16_384), hash = z.string().regex(/^0x[0-9a-fA-F]{64}$/);
+const address = z.string().regex(/^0x[0-9a-fA-F]{40}$/), digest = z.string().regex(/^[0-9a-f]{64}$/);
+const commitment = z.string().regex(/^sha256:[0-9a-f]{64}$/), time = z.number().int().nonnegative().safe();
+const pattern = /^(0|[1-9][0-9]{0,77})$/;
+const uint = (bits = 256) => z
+    .string()
+    .max(78)
+    .regex(pattern)
+    .refine((value) => pattern.test(value) && BigInt(value) < 1n << BigInt(bits));
+const operationId = z
+    .string()
+    .regex(/^sp_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+/** The canonical protocol operation ID is generated by this service, never accepted from the caller. */
+export const LP_USEROP_PUBLIC_INTENT_SCHEMA = LP_USEROP_INPUT_SCHEMA.omit({ operationId: true })
+    .extend({
+    tokenId: uint(),
+    amountMax: z.tuple([uint(128), uint(128)]),
+    amountMin: z.tuple([uint(), uint()]),
+})
+    .strict();
+export const LP_USEROP_ACCOUNT_PREPARE_INPUT = z
+    .object({ accessToken: token, input: LP_USEROP_PUBLIC_INTENT_SCHEMA })
+    .strict();
+export const LP_USEROP_ACCOUNT_READ_INPUT = z.object({ accessToken: token, operationId }).strict();
+export const LP_USEROP_ACCOUNT_SUBMIT_INPUT = LP_USEROP_ACCOUNT_READ_INPUT.extend({
+    envelopeCommitment: commitment,
+    reviewCommitment: digest,
+    confirmation: z.enum([LP_USEROP_CONFIRMATION, LP_USEROP_ACCOUNT_GAS_CONFIRMATION]),
+}).strict();
+const pair = z.tuple([uint(), uint()]);
+export const LP_USEROP_ACCOUNT_OPERATION_RESULT = z
+    .object({
+    schemaVersion: z.literal('1'),
+    kind: z.literal('lp-collect-userop'),
+    operationId,
+    account: address,
+    chainId: z.literal(8453),
+    protocol: z.literal('uniswap-v3'),
+    action: z.literal('guarded-collect'),
+    pool: address,
+    tokenId: uint(),
+    state: z.enum(['review', 'active', 'unknown', 'submitted', 'completed', 'failed']),
+    reviewConsumed: z.boolean(),
+    envelopeCommitment: commitment,
+    reviewCommitment: digest,
+    validUntilMs: time,
+    collection: z
+        .object({
+        tokens: z.tuple([address, address]),
+        maximum: pair,
+        minimum: pair,
+        tokensOwedAtReview: pair,
+        maximumAuthorized: pair,
+        mayIncludeOwedPrincipal: z.literal(true),
+        profitClassification: z.literal('UNKNOWN'),
+        distributableProfitRaw: z.null(),
+    })
+        .strict(),
+    gas: accountGasBudgetPublicSchema(uint()),
+    requiresOperationReview: z.boolean(),
+    confirmation: z.enum([LP_USEROP_CONFIRMATION, LP_USEROP_ACCOUNT_GAS_CONFIRMATION]),
+    protocolActionVerified: z.boolean(),
+    userOpHash: hash.optional(),
+    transactionHash: hash.optional(),
+    settlement: LP_USEROP_SETTLEMENT_SCHEMA.optional(),
+    failureCode: z
+        .enum([
+        'SPONSOR_NOT_SUBMITTED',
+        'SPONSOR_USER_OPERATION_REVERTED',
+        'SPONSOR_GAS_CAP_EXCEEDED',
+    ])
+        .optional(),
+    attention: z
+        .literal('The original provider request is unresolved. Read or reconcile this operation; do not submit a replacement.')
+        .optional(),
+    automaticExecutionEnabled: z.literal(false),
+    walletAuthorityChangeIncluded: z.literal(false),
+    retrySafe: z.literal(false),
+})
+    .strict()
+    .refine((value) => accountGasViewMatches(value) && value.confirmation === (value.gas.payer === 'account' ? LP_USEROP_ACCOUNT_GAS_CONFIRMATION : LP_USEROP_CONFIRMATION) && value.requiresOperationReview === (value.state === 'review') &&
+    value.reviewConsumed === (value.state !== 'review') &&
+    value.protocolActionVerified === (value.settlement?.status === 'completed') &&
+    (value.state !== 'completed' || value.settlement?.status === 'completed') &&
+    (!value.settlement ||
+        (value.settlement.status === 'completed'
+            ? value.state === 'completed'
+            : value.settlement.status === 'reverted' && value.state === 'failed')) &&
+    (!value.transactionHash || !!value.userOpHash) &&
+    (value.gas.payer !== 'sponsor' || !value.gas.activationChainHalted ||
+        (value.state === 'submitted' && value.failureCode === 'SPONSOR_GAS_CAP_EXCEEDED')), 'LP state must agree with the reviewed operation and canonical accounting proof');
+export function lpUserOpAccountView(operation) {
+    const { context } = operation, { input, baseline, terms } = assertLpUserOpEnvelope(context.envelope);
+    return freezeHybridValue(LP_USEROP_ACCOUNT_OPERATION_RESULT.parse({
+        schemaVersion: '1',
+        kind: 'lp-collect-userop',
+        operationId: operation.operationId,
+        account: context.account,
+        chainId: terms.chainId,
+        protocol: 'uniswap-v3',
+        action: 'guarded-collect',
+        pool: input.pool,
+        tokenId: input.tokenId,
+        state: operation.state,
+        reviewConsumed: operation.reviewConsumed,
+        envelopeCommitment: context.envelope.commitment,
+        reviewCommitment: operation.reviewCommitment,
+        validUntilMs: context.validUntilMs,
+        collection: {
+            tokens: [input.token0, input.token1],
+            maximum: input.amountMax,
+            minimum: input.amountMin,
+            tokensOwedAtReview: baseline.position.tokensOwed,
+            maximumAuthorized: terms.maximumCollectAtomic,
+            mayIncludeOwedPrincipal: true,
+            profitClassification: 'UNKNOWN',
+            distributableProfitRaw: null,
+        },
+        gas: accountGasView(operation, { maximumCostWei: terms.maxGasCostWei,
+            maximumUserCostWei: terms.maxUserGasCostWei, maximumActivationCostWei: terms.maxTotalGasCostWei }),
+        requiresOperationReview: operation.state === 'review',
+        confirmation: operation.gasReview?.payer === 'account' ? LP_USEROP_ACCOUNT_GAS_CONFIRMATION : LP_USEROP_CONFIRMATION,
+        protocolActionVerified: operation.settlement?.status === 'completed',
+        ...(operation.userOpHash ? { userOpHash: operation.userOpHash } : {}),
+        ...(operation.transactionHash ? { transactionHash: operation.transactionHash } : {}),
+        ...(operation.settlement ? { settlement: operation.settlement } : {}),
+        ...(operation.failureCode ? { failureCode: operation.failureCode } : {}),
+        ...(operation.state === 'unknown' && !operation.userOpHash
+            ? {
+                attention: 'The original provider request is unresolved. Read or reconcile this operation; do not submit a replacement.',
+            }
+            : {}),
+        automaticExecutionEnabled: false,
+        walletAuthorityChangeIncluded: false,
+        retrySafe: false,
+    }));
+}
+const equal = (left, right) => hybridYieldCommitment(left) === hybridYieldCommitment(right);
+function refuse(code) {
+    throw new Error(code);
+}
+/** Current invocation was refused before its provider callback ran; says nothing about older attempts. */
+export class LpUserOpPreHandoffRefusal extends Error {
+    constructor() {
+        super('LP_USEROP_REQUEST_REFUSED');
+        this.name = 'LpUserOpPreHandoffRefusal';
+    }
+}
+export class LpUserOpAccountService {
+    issuer;
+    protocol;
+    runtime;
+    store;
+    guards;
+    transport;
+    gasRuntime;
+    constructor(issuer, protocol, runtime, store, guards, transport, gasRuntime) {
+        this.issuer = issuer;
+        this.protocol = protocol;
+        this.runtime = runtime;
+        this.store = store;
+        this.guards = guards;
+        this.transport = transport;
+        this.gasRuntime = gasRuntime;
+    }
+    requireProtocol() {
+        return this.protocol ?? refuse('LP_USEROP_CHAIN_UNAVAILABLE');
+    }
+    async owned(accessToken, id) {
+        let userId;
+        try {
+            userId = (await this.runtime.cdp.endUser.validateAccessToken({ accessToken })).userId;
+        }
+        catch {
+            return refuse('LP_USEROP_SESSION_INVALID');
+        }
+        if (!/^[a-zA-Z0-9-]{1,100}$/.test(userId))
+            return refuse('LP_USEROP_SESSION_INVALID');
+        const operation = this.store.read(userId, id), who = await this.runtime.identity(accessToken, operation.context.account);
+        if (who.userId !== operation.userId)
+            return refuse('LP_USEROP_OWNER_MISMATCH');
+        return operation;
+    }
+    async prepare(raw) {
+        const request = LP_USEROP_ACCOUNT_PREPARE_INPUT.parse(raw);
+        this.store.assertReadyForNewOperations();
+        const input = LP_USEROP_INPUT_SCHEMA.parse({
+            ...request.input,
+            operationId: `lp_${randomUUID()}`,
+        });
+        let authority = await this.issuer.mint(request.accessToken, input);
+        const envelope = await prepareLpUserOp(this.requireProtocol(), input, this.issuer.terms(authority));
+        authority = await this.issuer.refresh(request.accessToken, authority);
+        const context = LP_USEROP_CONTEXT_SCHEMA.parse({
+            kind: 'lp-collect-userop',
+            account: envelope.terms.account,
+            chainId: envelope.terms.chainId,
+            envelope,
+            review: this.issuer.reviewRecord(authority),
+            authority: this.issuer.sponsorship(authority),
+            activation: this.issuer.activation(authority),
+            reviewedAtMs: envelope.preparedAtMs,
+            validUntilMs: envelope.validUntilMs,
+        });
+        const operation = this.store.transaction(() => {
+            this.issuer.assertCurrent(authority);
+            assertLpUserOpContext(context, true, this.runtime.now());
+            return this.store.create(context);
+        });
+        const guard = await this.guards.acquire('sponsored', operation.operationId, true);
+        guard.release();
+        if (context.activation.gasPaymentReviewEnabled) {
+            try {
+                return await this.reviewGas({ accessToken: request.accessToken,
+                    operationId: operation.operationId, reviewCommitment: operation.reviewCommitment, preference: 'auto' });
+            }
+            catch (error) {
+                return lpUserOpAccountView(this.store.recordGasReviewFailure(operation.userId, operation.operationId, accountGasFailure(error) ?? 'ACCOUNT_GAS_QUOTE_UNAVAILABLE'));
+            }
+        }
+        return lpUserOpAccountView(operation);
+    }
+    async reviewGas(raw) {
+        const input = SPONSORED_GAS_REVIEW_INPUT.extend({ operationId: LP_USEROP_ACCOUNT_READ_INPUT.shape.operationId }).parse(raw), owned = await this.owned(input.accessToken, input.operationId);
+        const guard = await this.guards.acquire('sponsored', owned.operationId, false);
+        try {
+            const operation = this.store.read(owned.userId, owned.operationId);
+            if (!this.gasRuntime || (operation.state !== 'review' && !(operation.state === 'failed' && !operation.handoffAttempted && operation.failureCode === 'SPONSOR_NOT_SUBMITTED')))
+                return refuse('ACCOUNT_GAS_REVIEW_UNAVAILABLE');
+            const authority = await this.issuer.restoreFromTrustedReview(input.accessToken, operation.context.review);
+            this.assertCurrentReview(operation, authority);
+            const gasReview = await this.gasRuntime.review(operation, lpUserOpRecordedCalls(operation.context.envelope), input.preference);
+            return lpUserOpAccountView(this.store.reviewGas(operation.userId, operation.operationId, input.reviewCommitment, gasReview));
+        }
+        finally {
+            guard.release();
+        }
+    }
+    async read(raw) {
+        const input = LP_USEROP_ACCOUNT_READ_INPUT.parse(raw);
+        return lpUserOpAccountView(await this.owned(input.accessToken, input.operationId));
+    }
+    assertCurrentReview(operation, authority) {
+        if (!equal(this.issuer.reviewRecord(authority), operation.context.review) ||
+            !equal(this.issuer.terms(authority), operation.context.envelope.terms))
+            return refuse('LP_USEROP_REVIEW_CHANGED');
+        assertLpUserOpContext(operation.context, true, this.runtime.now());
+    }
+    async submit(raw) {
+        let providerInvoked = false;
+        try {
+            return await this.submitOnce(raw, () => {
+                providerInvoked = true;
+            });
+        }
+        catch (error) {
+            if (!providerInvoked)
+                throw new LpUserOpPreHandoffRefusal();
+            throw error;
+        }
+    }
+    async submitOnce(raw, providerStarted) {
+        const input = LP_USEROP_ACCOUNT_SUBMIT_INPUT.parse(raw), owned = await this.owned(input.accessToken, input.operationId);
+        if (owned.state !== 'review' ||
+            owned.reviewConsumed ||
+            input.reviewCommitment !== owned.reviewCommitment ||
+            input.envelopeCommitment !== owned.context.envelope.commitment)
+            return refuse('LP_USEROP_REVIEW_REQUIRED');
+        if (input.confirmation !== (owned.gasReview?.payer === 'account' ? LP_USEROP_ACCOUNT_GAS_CONFIRMATION : LP_USEROP_CONFIRMATION))
+            throw new AccountGasConfirmationRefusal();
+        const guard = await this.guards.acquire('sponsored', owned.operationId, false);
+        try {
+            let authority = await this.issuer.restoreFromTrustedReview(input.accessToken, owned.context.review);
+            this.assertCurrentReview(owned, authority);
+            const simulation = await simulateLpUserOp(this.requireProtocol(), owned.context.envelope, this.issuer.terms(authority));
+            authority = await this.issuer.refresh(input.accessToken, authority);
+            this.assertCurrentReview(owned, authority);
+            this.store.transaction(() => {
+                this.store.begin(owned.userId, owned.operationId, input.reviewCommitment, this.issuer.sponsorship(authority));
+                this.issuer.assertCurrent(authority);
+            });
+            let handoffProof;
+            let unattemptedRecordCommitment;
+            try {
+                const operation = this.store.read(owned.userId, owned.operationId);
+                unattemptedRecordCommitment = hybridYieldCommitment(operation);
+                const request = this.transport.prepare({
+                    userId: operation.userId,
+                    account: operation.context.account,
+                    chainId: operation.context.chainId,
+                    idempotencyKey: operation.operationId.slice(3),
+                }, lpUserOpCalls(simulation), operation.gasReview?.payer ?? 'sponsor');
+                unattemptedRecordCommitment = hybridYieldCommitment(this.store.prepare(operation.userId, operation.operationId, request));
+                let verified;
+                let checkedGas;
+                const result = await this.transport.send(request, async () => {
+                    if (operation.context.activation.gasPaymentReviewEnabled && !this.gasRuntime)
+                        return refuse('ACCOUNT_GAS_REVIEW_UNAVAILABLE');
+                    checkedGas = await this.gasRuntime?.revalidate(operation, lpUserOpRecordedCalls(operation.context.envelope));
+                    // Finish all asynchronous protocol/profile and authority reads before the attempted stamp.
+                    verified = await verifyLpUserOp(this.requireProtocol(), operation.context.envelope, this.issuer.terms(authority));
+                    authority = await this.issuer.refresh(input.accessToken, authority);
+                    this.assertCurrentReview(operation, authority);
+                    assertFreshVerifiedLpUserOp(verified, this.runtime.now());
+                    unattemptedRecordCommitment = hybridYieldCommitment(this.store.recordLpVerification(operation.userId, operation.operationId, lpUserOpVerificationEvidence(verified)));
+                }, (start) => {
+                    handoffProof = this.store.attemptedWithProof(operation.userId, operation.operationId);
+                    return this.store.handoff(operation.userId, operation.operationId, () => {
+                        // Preserve journal -> caps ordering, including the shared gas circuit. No await follows the stamp.
+                        this.issuer.assertCurrent(authority);
+                        this.assertCurrentReview(operation, authority);
+                        return this.issuer.withCurrentCap(authority, () => {
+                            this.assertCurrentReview(operation, authority);
+                            if (!verified || !handoffProof)
+                                return refuse('LP_USEROP_HANDOFF_UNVERIFIED');
+                            assertFreshVerifiedLpUserOp(verified, this.runtime.now());
+                            return start((gasPolicy) => {
+                                this.gasRuntime?.assertFresh(operation, lpUserOpRecordedCalls(operation.context.envelope), checkedGas, gasPolicy);
+                                this.store.consumeHandoffProof(handoffProof);
+                                providerStarted();
+                            });
+                        });
+                    });
+                });
+                this.store.acknowledged(operation.userId, operation.operationId, result);
+            }
+            catch (error) {
+                const current = this.store.read(owned.userId, owned.operationId);
+                if (current.state === 'active' &&
+                    !current.handoffAttempted &&
+                    !current.userOpHash &&
+                    !current.transactionHash &&
+                    unattemptedRecordCommitment === hybridYieldCommitment(current))
+                    this.store.failBeforeHandoff(owned.userId, owned.operationId);
+                else if (handoffProof) {
+                    try {
+                        this.store.failUninvokedHandoff(handoffProof);
+                    }
+                    catch {
+                        /* Invoked, changed, restarted or uncertain journal state retains the original claim. */
+                    }
+                }
+                const gasFailure = accountGasFailure(error);
+                if (gasFailure)
+                    this.store.recordGasReviewFailure(owned.userId, owned.operationId, gasFailure);
+                return lpUserOpAccountView(this.store.read(owned.userId, owned.operationId));
+            }
+            return await this.reconcileOwned(this.store.read(owned.userId, owned.operationId));
+        }
+        finally {
+            guard.release();
+        }
+    }
+    /** Owned reconciliation survives expired review, Stop and removed delegation; it grants no new send authority. */
+    async reconcile(raw) {
+        const input = LP_USEROP_ACCOUNT_READ_INPUT.parse(raw), operation = await this.owned(input.accessToken, input.operationId);
+        if (['review', 'completed', 'failed'].includes(operation.state))
+            return lpUserOpAccountView(operation);
+        const guard = await this.guards.acquire('sponsored', operation.operationId, false);
+        try {
+            return await this.reconcileOwned(this.store.read(operation.userId, operation.operationId));
+        }
+        finally {
+            guard.release();
+        }
+    }
+    async reconcileOwned(operation) {
+        if (!operation.handoffAttempted)
+            return lpUserOpAccountView(this.store.failBeforeHandoff(operation.userId, operation.operationId));
+        if (!operation.userOpHash || !operation.submitEvidence)
+            return lpUserOpAccountView(operation);
+        try {
+            const acknowledgement = await this.runtime.readAcknowledgement(operation, lpUserOpRecordedCalls(operation.context.envelope));
+            operation = this.store.acknowledged(operation.userId, operation.operationId, acknowledgement);
+            if (!operation.transactionHash || !operation.submitEvidence)
+                return lpUserOpAccountView(operation);
+            const { terms } = operation.context.envelope;
+            const binding = {
+                userOpHash: operation.userOpHash,
+                transactionHash: operation.transactionHash,
+            };
+            const receipt = await readConfirmedSponsoredReceipt({
+                ...binding,
+                chainId: terms.chainId,
+                account: terms.account,
+                entryPoint: terms.entryPoint,
+                payer: operation.gasReview?.payer ?? 'sponsor',
+                paymaster: operation.gasReview?.payer === 'account' ? '0x0000000000000000000000000000000000000000' : terms.paymaster,
+                maxGasCostWei: BigInt(terms.maxGasCostWei),
+            }, this.runtime.client(terms.chainId));
+            const settlement = await readLpUserOpSettlement(operation.context.envelope, binding, this.requireProtocol(), operation.submitEvidence, operation.gasReview?.payer ?? 'sponsor');
+            if (!settlement.releaseClaim)
+                return lpUserOpAccountView(this.store.read(operation.userId, operation.operationId));
+            return lpUserOpAccountView(this.store.finish(operation.userId, operation.operationId, receipt, settlement));
+        }
+        catch (error) {
+            if (error instanceof SponsoredReceiptUnconfirmedError &&
+                error.code === 'SPONSOR_GAS_CAP_EXCEEDED' &&
+                error.breachedReceipt)
+                return lpUserOpAccountView(this.store.recordGasCapBreach(operation.userId, operation.operationId, error.breachedReceipt));
+            return lpUserOpAccountView(this.store.read(operation.userId, operation.operationId));
+        }
+    }
+}
+//# sourceMappingURL=lp-userop-account.js.map

package/dist/lp-userop-authority.d.ts

@@ -0,0 +1,49 @@
+import { type SponsoredActivation, type SponsoredAuthority } from './execution-sponsored-definition.js';
+import { SponsoredAccountRuntime } from './execution-sponsored-runtime.js';
+import { type NativeYieldAccountActivation } from './native-yield-account-definition.js';
+import { type LpUserOpActivation, type LpUserOpReviewRecord, type LpUserOpTerms } from './lp-userop-definition.js';
+export declare class LpUserOpAuthorityRefusal extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+declare const brand: unique symbol;
+/** Only this issuer can turn fresh authenticated facts into an operation authority. */
+export interface LpUserOpAuthority {
+    readonly [brand]: true;
+}
+export declare class LpUserOpAuthorityIssuer {
+    private readonly sponsor;
+    private readonly issued;
+    private readonly capLocked;
+    private readonly nativeActivations;
+    private readonly sponsorActivations;
+    private readonly lpActivations;
+    constructor(sponsor: SponsoredAccountRuntime, 
+    /** Internal fixtures only; the production constructor reads three empty reviewed source arrays. */
+    fixtures?: {
+        nativeActivations: readonly NativeYieldAccountActivation[];
+        sponsoredActivations: readonly SponsoredActivation[];
+        lpActivations: readonly LpUserOpActivation[];
+    });
+    private now;
+    private sources;
+    private window;
+    private derivedTerms;
+    private facts;
+    private issue;
+    mint(accessToken: string, rawInput: unknown): Promise<LpUserOpAuthority>;
+    private read;
+    refresh(accessToken: string, authority: LpUserOpAuthority): Promise<LpUserOpAuthority>;
+    /** Only immutable trusted journal context may enter here; never caller-supplied terms. */
+    restoreFromTrustedReview(accessToken: string, rawReview: unknown): Promise<LpUserOpAuthority>;
+    private assertScope;
+    /** Synchronous source/time and Stop check, including inside the caller's shared-journal stamp. */
+    assertCurrent(authority: LpUserOpAuthority): void;
+    /** The existing cap writer lock orders Stop against the synchronous provider POST invocation. */
+    withCurrentCap<T>(authority: LpUserOpAuthority, start: () => T): T;
+    terms(authority: LpUserOpAuthority): LpUserOpTerms;
+    reviewRecord(authority: LpUserOpAuthority): LpUserOpReviewRecord;
+    sponsorship(authority: LpUserOpAuthority): SponsoredAuthority;
+    activation(authority: LpUserOpAuthority): SponsoredActivation;
+}
+export {};