@lit-protocol/vincent-app-sdk 0.0.4-ea

package/dist/src/abilityClient/precheck/types.d.ts

@@ -0,0 +1,82 @@
+import type { z } from 'zod';
+import type { BaseAbilityContext, SchemaValidationError } from '@lit-protocol/vincent-ability-sdk';
+import type { VincentPolicy } from '@lit-protocol/vincent-ability-sdk/internal';
+/** @category Interfaces */
+export interface AbilityPrecheckResponseSuccess<Result, Policies extends Record<string, any>> {
+    success: true;
+    result: Result;
+    context?: BaseAbilityContext<PolicyPrecheckResultContext<Policies>>;
+}
+/** @category Interfaces */
+export interface AbilityPrecheckResponseSuccessNoResult<Policies extends Record<string, any>> {
+    success: true;
+    result?: never;
+    context?: BaseAbilityContext<PolicyPrecheckResultContext<Policies>>;
+}
+/** @category Interfaces */
+export interface AbilityPrecheckResponseFailure<Result, Policies extends Record<string, any>> {
+    success: false;
+    runtimeError?: string;
+    schemaValidationError?: SchemaValidationError;
+    result: Result;
+    context?: BaseAbilityContext<PolicyPrecheckResultContext<Policies>>;
+}
+/** @category Interfaces */
+export interface AbilityPrecheckResponseFailureNoResult<Policies extends Record<string, any>> {
+    success: false;
+    runtimeError?: string;
+    schemaValidationError?: SchemaValidationError;
+    result?: never;
+    context?: BaseAbilityContext<PolicyPrecheckResultContext<Policies>>;
+}
+/** @category Interfaces */
+export type AbilityPrecheckResponse<SuccessSchema extends z.ZodType | undefined, FailSchema extends z.ZodType | undefined, Policies extends Record<string, any>> = (SuccessSchema extends z.ZodType ? AbilityPrecheckResponseSuccess<z.infer<SuccessSchema>, Policies> : AbilityPrecheckResponseSuccessNoResult<Policies>) | (FailSchema extends z.ZodType ? AbilityPrecheckResponseFailure<z.infer<FailSchema>, Policies> : AbilityPrecheckResponseFailureNoResult<Policies>);
+export interface RemoteVincentAbilityExecutionResult<SuccessSchema extends z.ZodType | undefined, FailSchema extends z.ZodType | undefined, Policies extends Record<string, any>> {
+    abilityExecutionResult: AbilityPrecheckResponse<SuccessSchema, FailSchema, Policies>;
+    abilityContext: BaseAbilityContext<PolicyPrecheckResultContext<Policies>>;
+}
+export type PolicyPrecheckResultContext<Policies extends Record<string, {
+    vincentPolicy: VincentPolicy<any, any, any, any, any, any, any, any, any, any>;
+    /** @hidden */
+    __schemaTypes?: {
+        policyAbilityParamsSchema: z.ZodType;
+        userParamsSchema?: z.ZodType;
+        evalAllowResultSchema?: z.ZodType;
+        evalDenyResultSchema?: z.ZodType;
+        commitParamsSchema?: z.ZodType;
+        commitAllowResultSchema?: z.ZodType;
+        commitDenyResultSchema?: z.ZodType;
+        evaluate?: Function;
+        precheck?: Function;
+        commit?: Function;
+    };
+}>> = {
+    evaluatedPolicies: Array<keyof Policies>;
+} & ({
+    allow: true;
+    allowedPolicies: {
+        [PolicyKey in keyof Policies]?: {
+            result: Policies[PolicyKey]['__schemaTypes'] extends {
+                precheckAllowResultSchema: infer Schema;
+            } ? Schema extends z.ZodType ? z.infer<Schema> : never : never;
+        };
+    };
+    deniedPolicy?: never;
+} | {
+    allow: false;
+    deniedPolicy: {
+        runtimeError?: string;
+        packageName: keyof Policies;
+        result: (Policies[Extract<keyof Policies, string>]['__schemaTypes'] extends {
+            precheckDenyResultSchema: infer Schema;
+        } ? Schema extends z.ZodType ? z.infer<Schema> : undefined : undefined) | undefined;
+    };
+    allowedPolicies?: {
+        [PolicyKey in keyof Policies]?: {
+            result: Policies[PolicyKey]['__schemaTypes'] extends {
+                precheckAllowResultSchema: infer Schema;
+            } ? Schema extends z.ZodType ? z.infer<Schema> : never : never;
+        };
+    };
+});
+//# sourceMappingURL=types.d.ts.map

package/dist/src/abilityClient/precheck/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/abilityClient/precheck/types.ts"],"names":[],"mappings":"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"}

package/dist/src/abilityClient/precheck/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// src/lib/abilityClient/precheck/types.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/abilityClient/precheck/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/abilityClient/precheck/types.ts"],"names":[],"mappings":";AAAA,0CAA0C"}

package/dist/src/abilityClient/typeGuards.d.ts

@@ -0,0 +1,28 @@
+import type { RemoteVincentAbilityExecutionResult, AbilityExecuteResponse, AbilityExecuteResponseFailure, AbilityExecuteResponseFailureNoResult, AbilityExecuteResponseSuccess, AbilityExecuteResponseSuccessNoResult } from './execute/types';
+/** Type guard function that returns true only if the passed value is a successful ability response
+ * @category API
+ * */
+export declare function isAbilityResponseSuccess(value: unknown): value is AbilityExecuteResponseSuccess<any, Record<string, any>> | AbilityExecuteResponseSuccessNoResult<Record<string, any>>;
+/** Type guard function that returns true only if the passed value is a failure ability response
+ *  @category API */
+export declare function isAbilityResponseFailure(value: unknown): value is AbilityExecuteResponseFailure<any, Record<string, any>> | AbilityExecuteResponseFailureNoResult<Record<string, any>>;
+/** Type guard function that returns true only if the passed value is a failure ability response that was a runtime error
+ * This could be caused by code `throw()`ing an error from inside ability or policy code, or by errors encountered in the
+ * Vincent SDK wrapping code that handles the execution of the ability/policies.
+ *
+ * This could also be the result of a schema validation error -- use {@link isAbilityResponseSchemaValidationFailure} to check
+ * to see if have a data validation error.
+ *
+ *  @category API*/
+export declare function isAbilityResponseRuntimeFailure(value: unknown): value is AbilityExecuteResponseFailureNoResult<Record<string, any>>;
+/** Type guard function that returns true only if the passed value is a failure ability response that was caused by
+ * a schema parsing failure.  All data inputs and outputs to / from Vincent Abilities and Policies is validated using ZOD schemas.
+ *
+ * If this returns true, you can parse the `schemaValidationError` property in the response - it is a ZodError object.
+ * @category API */
+export declare function isAbilityResponseSchemaValidationFailure(value: unknown): value is AbilityExecuteResponseFailureNoResult<Record<string, any>>;
+/** @hidden */
+export declare function isAbilityResponse(value: unknown): value is AbilityExecuteResponse<any, any, Record<string, any>>;
+/** @hidden */
+export declare function isRemoteVincentAbilityExecutionResult(value: unknown): value is RemoteVincentAbilityExecutionResult<any, any, Record<any, any>>;
+//# sourceMappingURL=typeGuards.d.ts.map

package/dist/src/abilityClient/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["../../../src/abilityClient/typeGuards.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mCAAmC,EACnC,sBAAsB,EACtB,6BAA6B,EAC7B,qCAAqC,EACrC,6BAA6B,EAC7B,qCAAqC,EACtC,MAAM,iBAAiB,CAAC;AAEzB;;KAEK;AACL,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,KAAK,IACJ,6BAA6B,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GACvD,qCAAqC,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAO7D;AAED;oBACoB;AACpB,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,KAAK,IACJ,6BAA6B,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GACvD,qCAAqC,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAO7D;AAED;;;;;;;mBAOmB;AACnB,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,qCAAqC,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAIrE;AAED;;;;mBAImB;AACnB,wBAAgB,wCAAwC,CACtD,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,qCAAqC,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAKrE;AAED,cAAc;AACd,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,sBAAsB,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAOhE;AAED,cAAc;AACd,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,mCAAmC,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAU1E"}

package/dist/src/abilityClient/typeGuards.js

@@ -0,0 +1,67 @@
+"use strict";
+// src/lib/abilityClient/typeGuards.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbilityResponseSuccess = isAbilityResponseSuccess;
+exports.isAbilityResponseFailure = isAbilityResponseFailure;
+exports.isAbilityResponseRuntimeFailure = isAbilityResponseRuntimeFailure;
+exports.isAbilityResponseSchemaValidationFailure = isAbilityResponseSchemaValidationFailure;
+exports.isAbilityResponse = isAbilityResponse;
+exports.isRemoteVincentAbilityExecutionResult = isRemoteVincentAbilityExecutionResult;
+/** Type guard function that returns true only if the passed value is a successful ability response
+ * @category API
+ * */
+function isAbilityResponseSuccess(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'success' in value &&
+        value.success === true);
+}
+/** Type guard function that returns true only if the passed value is a failure ability response
+ *  @category API */
+function isAbilityResponseFailure(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'success' in value &&
+        value.success === false);
+}
+/** Type guard function that returns true only if the passed value is a failure ability response that was a runtime error
+ * This could be caused by code `throw()`ing an error from inside ability or policy code, or by errors encountered in the
+ * Vincent SDK wrapping code that handles the execution of the ability/policies.
+ *
+ * This could also be the result of a schema validation error -- use {@link isAbilityResponseSchemaValidationFailure} to check
+ * to see if have a data validation error.
+ *
+ *  @category API*/
+function isAbilityResponseRuntimeFailure(value) {
+    if (!isAbilityResponseFailure(value))
+        return false;
+    return 'runtimeError' in value && typeof value.runtimeError === 'string';
+}
+/** Type guard function that returns true only if the passed value is a failure ability response that was caused by
+ * a schema parsing failure.  All data inputs and outputs to / from Vincent Abilities and Policies is validated using ZOD schemas.
+ *
+ * If this returns true, you can parse the `schemaValidationError` property in the response - it is a ZodError object.
+ * @category API */
+function isAbilityResponseSchemaValidationFailure(value) {
+    if (!isAbilityResponseFailure(value))
+        return false;
+    return ('schemaValidationError' in value && typeof value.schemaValidationError === 'object');
+}
+/** @hidden */
+function isAbilityResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'success' in value &&
+        typeof value.success === 'boolean');
+}
+/** @hidden */
+function isRemoteVincentAbilityExecutionResult(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'abilityExecutionResult' in value &&
+        'abilityContext' in value &&
+        isAbilityResponse(value.abilityExecutionResult) &&
+        typeof value.abilityContext === 'object' &&
+        value.abilityContext !== null);
+}
+//# sourceMappingURL=typeGuards.js.map

package/dist/src/abilityClient/typeGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.js","sourceRoot":"","sources":["../../../src/abilityClient/typeGuards.ts"],"names":[],"mappings":";AAAA,sCAAsC;;AActC,4DAWC;AAID,4DAWC;AAUD,0EAMC;AAOD,4FAOC;AAGD,8CASC;AAGD,sFAYC;AAtFD;;KAEK;AACL,SAAgB,wBAAwB,CACtC,KAAc;IAId,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,SAAS,IAAI,KAAK;QACjB,KAAa,CAAC,OAAO,KAAK,IAAI,CAChC,CAAC;AACJ,CAAC;AAED;oBACoB;AACpB,SAAgB,wBAAwB,CACtC,KAAc;IAId,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,SAAS,IAAI,KAAK;QACjB,KAAa,CAAC,OAAO,KAAK,KAAK,CACjC,CAAC;AACJ,CAAC;AAED;;;;;;;mBAOmB;AACnB,SAAgB,+BAA+B,CAC7C,KAAc;IAEd,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAEnD,OAAO,cAAc,IAAI,KAAK,IAAI,OAAQ,KAAa,CAAC,YAAY,KAAK,QAAQ,CAAC;AACpF,CAAC;AAED;;;;mBAImB;AACnB,SAAgB,wCAAwC,CACtD,KAAc;IAEd,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACnD,OAAO,CACL,uBAAuB,IAAI,KAAK,IAAI,OAAQ,KAAa,CAAC,qBAAqB,KAAK,QAAQ,CAC7F,CAAC;AACJ,CAAC;AAED,cAAc;AACd,SAAgB,iBAAiB,CAC/B,KAAc;IAEd,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,SAAS,IAAI,KAAK;QAClB,OAAQ,KAAa,CAAC,OAAO,KAAK,SAAS,CAC5C,CAAC;AACJ,CAAC;AAED,cAAc;AACd,SAAgB,qCAAqC,CACnD,KAAc;IAEd,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,wBAAwB,IAAI,KAAK;QACjC,gBAAgB,IAAI,KAAK;QACzB,iBAAiB,CAAE,KAAa,CAAC,sBAAsB,CAAC;QACxD,OAAQ,KAAa,CAAC,cAAc,KAAK,QAAQ;QAChD,KAAa,CAAC,cAAc,KAAK,IAAI,CACvC,CAAC;AACJ,CAAC"}

package/dist/src/abilityClient/types.d.ts

@@ -0,0 +1,50 @@
+import type { z } from 'zod';
+import type { BaseAbilityContext } from '@lit-protocol/vincent-ability-sdk';
+import type { AbilityExecuteResponse } from './execute/types';
+import type { AbilityPrecheckResponse } from './precheck/types';
+export { type BaseAbilityContext };
+/**
+ * The Vincent Ability Client is used to interact with Vincent abilities.
+ *
+ * - Precheck ability parameters and policies
+ * - Execute abilities remotely
+ *
+ * @typeParam AbilityParamsSchema {@removeTypeParameterCompletely}
+ * @typeParam PoliciesByPackageName {@removeTypeParameterCompletely}
+ * @typeParam ExecuteSuccessSchema {@removeTypeParameterCompletely}
+ * @typeParam ExecuteFailSchema {@removeTypeParameterCompletely}
+ * @typeParam PrecheckSuccessSchema {@removeTypeParameterCompletely}
+ * @typeParam PrecheckFailSchema {@removeTypeParameterCompletely}
+ *
+ * @category Interfaces
+ */
+export interface VincentAbilityClient<AbilityParamsSchema extends z.ZodType, PoliciesByPackageName extends Record<string, any>, ExecuteSuccessSchema extends z.ZodType = z.ZodUndefined, ExecuteFailSchema extends z.ZodType = z.ZodUndefined, PrecheckSuccessSchema extends z.ZodType = z.ZodUndefined, PrecheckFailSchema extends z.ZodType = z.ZodUndefined> {
+    /**
+     * Performs a precheck of the ability parameters and policies.
+     *
+     * This method validates the ability parameters and checks if the policies allow the ability to be executed.
+     *
+     * @param rawAbilityParams - The parameters to be passed to the ability
+     * @param context - The context for the ability execution, including the delegator PKP Ethereum address
+     * @returns A promise that resolves to a AbilityResponse containing the precheck result
+     */
+    precheck(rawAbilityParams: z.infer<AbilityParamsSchema>, context: AbilityClientContext & {
+        rpcUrl?: string;
+    }): Promise<AbilityPrecheckResponse<PrecheckSuccessSchema, PrecheckFailSchema, PoliciesByPackageName>>;
+    /**
+     * Executes the ability with the given parameters.
+     *
+     * This method validates the ability parameters, executes the ability remotely, and returns the result.
+     *
+     * @param rawAbilityParams - The parameters to be passed to the ability
+     * @param context - The context for the ability execution, including the delegator PKP Ethereum address
+     * @returns A promise that resolves to a AbilityResponse containing the execution result
+     *
+     */
+    execute(rawAbilityParams: z.infer<AbilityParamsSchema>, context: AbilityClientContext): Promise<AbilityExecuteResponse<ExecuteSuccessSchema, ExecuteFailSchema, PoliciesByPackageName>>;
+}
+/** @category Interfaces */
+export interface AbilityClientContext {
+    delegatorPkpEthAddress: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/abilityClient/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/abilityClient/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAE5E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAEhE,OAAO,EAAE,KAAK,kBAAkB,EAAE,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,oBAAoB,CACnC,mBAAmB,SAAS,CAAC,CAAC,OAAO,EACrC,qBAAqB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjD,oBAAoB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,YAAY,EACvD,iBAAiB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,YAAY,EACpD,qBAAqB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,YAAY,EACxD,kBAAkB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,YAAY;IAErD;;;;;;;;OAQG;IACH,QAAQ,CACN,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAC9C,OAAO,EAAE,oBAAoB,GAAG;QAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GACA,OAAO,CACR,uBAAuB,CAAC,qBAAqB,EAAE,kBAAkB,EAAE,qBAAqB,CAAC,CAC1F,CAAC;IAEF;;;;;;;;;OASG;IACH,OAAO,CACL,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAC9C,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CACR,sBAAsB,CAAC,oBAAoB,EAAE,iBAAiB,EAAE,qBAAqB,CAAC,CACvF,CAAC;CACH;AAED,2BAA2B;AAC3B,MAAM,WAAW,oBAAoB;IACnC,sBAAsB,EAAE,MAAM,CAAC;CAChC"}

package/dist/src/abilityClient/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// src/lib/abilityClient/types.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/abilityClient/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/abilityClient/types.ts"],"names":[],"mappings":";AAAA,iCAAiC"}

package/dist/src/abilityClient/vincentAbilityClient.d.ts

@@ -0,0 +1,76 @@
+import { ethers } from 'ethers';
+import { z } from 'zod';
+import type { BundledVincentAbility, VincentAbility } from '@lit-protocol/vincent-ability-sdk';
+import type { AbilityPolicyMap } from '@lit-protocol/vincent-ability-sdk/internal';
+import type { VincentAbilityClient } from './types';
+/** A VincentAbilityClient provides a type-safe interface for executing abilities, for both `precheck()`
+ * and `execute()` functionality.
+ *
+ * ```typescript
+ * import { disconnectVincentAbilityClients, getVincentAbilityClient, isAbilityResponseFailure } from '@lit-protocol/vincent-app-sdk/abilityClient';
+ * import { bundledVincentAbility as uniswapBundledAbility } from '@lit-protocol/vincent-ability-uniswap-swap';
+ * import { delegateeEthersSigner } = from './ethersSigner';
+ * import { ETH_RPC_URL, BASE_RPC_URL } from './rpcConfigs';
+ *
+ * const uniswapAbilityClient = getVincentAbilityClient({
+ *     bundledVincentAbility: uniswapBundledAbility,
+ *     ethersSigner: delegateeEthersSigner,
+ *   });
+ *
+ * // First, call `precheck()` to get a best-estimate result indicating that the ability execution in the LIT action runtime will not fail
+ * const precheckResult = await uniswapSwapAbilityClient.precheck({
+ *     ethRpcUrl: ETH_RPC_URL,
+ *     rpcUrlForUniswap: BASE_RPC_URL,
+ *     chainIdForUniswap: 8453, // Base
+ *     tokenInAddress: '0x4200000000000000000000000000000000000006', // WETH
+ *     tokenInDecimals: 18,
+ *     tokenInAmount: 0.0000077,
+ *     tokenOutAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+ *     tokenOutDecimals: 8,
+ *   },
+ *   {
+ *     delegatorPkpEthAddress: '0x123456789123456789123456789...',
+ *   });
+ *
+ * const uniswapSwapExecutionResult = await uniswapSwapAbilityClient.execute({
+ *   ethRpcUrl: ETH_RPC_URL,
+ *   rpcUrlForUniswap: BASE_RPC_URL,
+ *   chainIdForUniswap: 8453,
+ *   tokenInAddress: '0x4200000000000000000000000000000000000006', // WETH
+ *   tokenInDecimals: 18,
+ *   tokenInAmount: 0.0000077,
+ *   tokenOutAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+ *   tokenOutDecimals: 8,
+ * },
+ * {
+ *   delegatorPkpEthAddress: '0x123456789123456789123456789...',
+ * });
+ *
+ * if(isAbilityResponseFailure(uniswapSwapExecutionResult)) {
+ *   ...handle failure
+ * } else {
+ *  ...handle result
+ * }
+ * ```
+ *
+ * @typeParam IpfsCid {@removeTypeParameterCompletely}
+ * @typeParam AbilityParamsSchema {@removeTypeParameterCompletely}
+ * @typeParam PkgNames {@removeTypeParameterCompletely}
+ * @typeParam PolicyMap {@removeTypeParameterCompletely}
+ * @typeParam PoliciesByPackageName {@removeTypeParameterCompletely}
+ * @typeParam ExecuteSuccessSchema {@removeTypeParameterCompletely}
+ * @typeParam ExecuteFailSchema {@removeTypeParameterCompletely}
+ * @typeParam PrecheckSuccessSchema {@removeTypeParameterCompletely}
+ * @typeParam PrecheckFailSchema {@removeTypeParameterCompletely}
+ *
+ * @param params
+ * @param params.ethersSigner  - An ethers signer that has been configured with your delegatee key
+ * @param params.bundledVincentAbility  - The bundled vincent ability that you want to interact with
+ *
+ * @category API
+ * */
+export declare function getVincentAbilityClient<const IpfsCid extends string, AbilityParamsSchema extends z.ZodType, PkgNames extends string, PolicyMap extends AbilityPolicyMap<any, PkgNames>, PoliciesByPackageName extends PolicyMap['policyByPackageName'], ExecuteSuccessSchema extends z.ZodType = z.ZodUndefined, ExecuteFailSchema extends z.ZodType = z.ZodUndefined, PrecheckSuccessSchema extends z.ZodType = z.ZodUndefined, PrecheckFailSchema extends z.ZodType = z.ZodUndefined>(params: {
+    bundledVincentAbility: BundledVincentAbility<VincentAbility<AbilityParamsSchema, PkgNames, PolicyMap, PoliciesByPackageName, ExecuteSuccessSchema, ExecuteFailSchema, PrecheckSuccessSchema, PrecheckFailSchema, any, any>, IpfsCid>;
+    ethersSigner: ethers.Signer;
+}): VincentAbilityClient<AbilityParamsSchema, PoliciesByPackageName, ExecuteSuccessSchema, ExecuteFailSchema, PrecheckSuccessSchema, PrecheckFailSchema>;
+//# sourceMappingURL=vincentAbilityClient.d.ts.map

package/dist/src/abilityClient/vincentAbilityClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vincentAbilityClient.d.ts","sourceRoot":"","sources":["../../../src/abilityClient/vincentAbilityClient.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAC/F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAcnF,OAAO,KAAK,EAAwB,oBAAoB,EAAE,MAAM,SAAS,CAAC;AA2B1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiEK;AACL,wBAAgB,uBAAuB,CACrC,KAAK,CAAC,OAAO,SAAS,MAAM,EAC5B,mBAAmB,SAAS,CAAC,CAAC,OAAO,EACrC,QAAQ,SAAS,MAAM,EACvB,SAAS,SAAS,gBAAgB,CAAC,GAAG,EAAE,QAAQ,CAAC,EACjD,qBAAqB,SAAS,SAAS,CAAC,qBAAqB,CAAC,EAC9D,oBAAoB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,YAAY,EACvD,iBAAiB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,YAAY,EACpD,qBAAqB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,YAAY,EACxD,kBAAkB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,YAAY,EACrD,MAAM,EAAE;IACR,qBAAqB,EAAE,qBAAqB,CAC1C,cAAc,CACZ,mBAAmB,EACnB,QAAQ,EACR,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,GAAG,EACH,GAAG,CACJ,EACD,OAAO,CACR,CAAC;IACF,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC;CAC7B,GAAG,oBAAoB,CACtB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,CACnB,CAmWA"}

package/dist/src/abilityClient/vincentAbilityClient.js

@@ -0,0 +1,285 @@
+"use strict";
+// src/abilityClient/vincentAbilityClient.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVincentAbilityClient = getVincentAbilityClient;
+const ethers_1 = require("ethers");
+const zod_1 = require("zod");
+const constants_1 = require("@lit-protocol/constants");
+const internal_1 = require("@lit-protocol/vincent-ability-sdk/internal");
+const getLitNodeClient_1 = require("../internal/LitNodeClient/getLitNodeClient");
+const generateVincentAbilitySessionSigs_1 = require("./execute/generateVincentAbilitySessionSigs");
+const resultCreators_1 = require("./execute/resultCreators");
+const resultCreators_2 = require("./precheck/resultCreators");
+const runPolicyPrechecks_1 = require("./precheck/runPolicyPrechecks");
+const typeGuards_1 = require("./typeGuards");
+const YELLOWSTONE_RPC_URL = 'https://yellowstone-rpc.litprotocol.com/';
+const bigintReplacer = (key, value) => {
+    return typeof value === 'bigint' ? value.toString() : value;
+};
+/** A VincentAbilityClient provides a type-safe interface for executing abilities, for both `precheck()`
+ * and `execute()` functionality.
+ *
+ * ```typescript
+ * import { disconnectVincentAbilityClients, getVincentAbilityClient, isAbilityResponseFailure } from '@lit-protocol/vincent-app-sdk/abilityClient';
+ * import { bundledVincentAbility as uniswapBundledAbility } from '@lit-protocol/vincent-ability-uniswap-swap';
+ * import { delegateeEthersSigner } = from './ethersSigner';
+ * import { ETH_RPC_URL, BASE_RPC_URL } from './rpcConfigs';
+ *
+ * const uniswapAbilityClient = getVincentAbilityClient({
+ *     bundledVincentAbility: uniswapBundledAbility,
+ *     ethersSigner: delegateeEthersSigner,
+ *   });
+ *
+ * // First, call `precheck()` to get a best-estimate result indicating that the ability execution in the LIT action runtime will not fail
+ * const precheckResult = await uniswapSwapAbilityClient.precheck({
+ *     ethRpcUrl: ETH_RPC_URL,
+ *     rpcUrlForUniswap: BASE_RPC_URL,
+ *     chainIdForUniswap: 8453, // Base
+ *     tokenInAddress: '0x4200000000000000000000000000000000000006', // WETH
+ *     tokenInDecimals: 18,
+ *     tokenInAmount: 0.0000077,
+ *     tokenOutAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+ *     tokenOutDecimals: 8,
+ *   },
+ *   {
+ *     delegatorPkpEthAddress: '0x123456789123456789123456789...',
+ *   });
+ *
+ * const uniswapSwapExecutionResult = await uniswapSwapAbilityClient.execute({
+ *   ethRpcUrl: ETH_RPC_URL,
+ *   rpcUrlForUniswap: BASE_RPC_URL,
+ *   chainIdForUniswap: 8453,
+ *   tokenInAddress: '0x4200000000000000000000000000000000000006', // WETH
+ *   tokenInDecimals: 18,
+ *   tokenInAmount: 0.0000077,
+ *   tokenOutAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+ *   tokenOutDecimals: 8,
+ * },
+ * {
+ *   delegatorPkpEthAddress: '0x123456789123456789123456789...',
+ * });
+ *
+ * if(isAbilityResponseFailure(uniswapSwapExecutionResult)) {
+ *   ...handle failure
+ * } else {
+ *  ...handle result
+ * }
+ * ```
+ *
+ * @typeParam IpfsCid {@removeTypeParameterCompletely}
+ * @typeParam AbilityParamsSchema {@removeTypeParameterCompletely}
+ * @typeParam PkgNames {@removeTypeParameterCompletely}
+ * @typeParam PolicyMap {@removeTypeParameterCompletely}
+ * @typeParam PoliciesByPackageName {@removeTypeParameterCompletely}
+ * @typeParam ExecuteSuccessSchema {@removeTypeParameterCompletely}
+ * @typeParam ExecuteFailSchema {@removeTypeParameterCompletely}
+ * @typeParam PrecheckSuccessSchema {@removeTypeParameterCompletely}
+ * @typeParam PrecheckFailSchema {@removeTypeParameterCompletely}
+ *
+ * @param params
+ * @param params.ethersSigner  - An ethers signer that has been configured with your delegatee key
+ * @param params.bundledVincentAbility  - The bundled vincent ability that you want to interact with
+ *
+ * @category API
+ * */
+function getVincentAbilityClient(params) {
+    var _a, _b;
+    const { bundledVincentAbility, ethersSigner } = params;
+    const { ipfsCid, vincentAbility, vincentAbilityApiVersion } = bundledVincentAbility;
+    (0, internal_1.assertSupportedAbilityVersion)(vincentAbilityApiVersion);
+    const network = constants_1.LIT_NETWORK.Datil;
+    const executeSuccessSchema = ((_a = vincentAbility.__schemaTypes.executeSuccessSchema) !== null && _a !== void 0 ? _a : zod_1.z.undefined());
+    const executeFailSchema = ((_b = vincentAbility.__schemaTypes.executeFailSchema) !== null && _b !== void 0 ? _b : zod_1.z.undefined());
+    return {
+        async precheck(rawAbilityParams, { rpcUrl, delegatorPkpEthAddress, }) {
+            console.log('precheck', { rawAbilityParams, delegatorPkpEthAddress, rpcUrl });
+            const delegateePkpEthAddress = ethers_1.ethers.utils.getAddress(await ethersSigner.getAddress());
+            // This will be populated further during execution; if an error is encountered, it'll include as much data as we can give the caller.
+            const baseContext = {
+                delegation: {
+                    delegateeAddress: delegateePkpEthAddress,
+                    // delegatorPkpInfo: null,
+                },
+                abilityIpfsCid: ipfsCid,
+                // appId: undefined,
+                // appVersion: undefined,
+            };
+            const parsedParams = (0, internal_1.validateOrFail)(rawAbilityParams, vincentAbility.abilityParamsSchema, 'precheck', 'input');
+            if ((0, typeGuards_1.isAbilityResponseFailure)(parsedParams)) {
+                return (0, resultCreators_2.createAbilityPrecheckResponseFailureNoResult)({
+                    ...parsedParams,
+                    context: baseContext,
+                });
+            }
+            const userPkpInfo = await (0, internal_1.getPkpInfo)({
+                litPubkeyRouterAddress: internal_1.LIT_DATIL_PUBKEY_ROUTER_ADDRESS,
+                yellowstoneRpcUrl: rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : YELLOWSTONE_RPC_URL,
+                pkpEthAddress: delegatorPkpEthAddress,
+            });
+            baseContext.delegation.delegatorPkpInfo = userPkpInfo;
+            console.log('userPkpInfo', userPkpInfo);
+            const { decodedPolicies, appId, appVersion } = await (0, internal_1.getPoliciesAndAppVersion)({
+                delegationRpcUrl: rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : YELLOWSTONE_RPC_URL,
+                appDelegateeAddress: delegateePkpEthAddress,
+                agentWalletPkpEthAddress: delegatorPkpEthAddress,
+                abilityIpfsCid: ipfsCid,
+            });
+            baseContext.appId = appId.toNumber();
+            baseContext.appVersion = appVersion.toNumber();
+            console.log('Fetched policies and app info', { decodedPolicies, appId, appVersion });
+            const baseAbilityContext = await (0, runPolicyPrechecks_1.runAbilityPolicyPrechecks)({
+                bundledVincentAbility,
+                abilityParams: parsedParams,
+                decodedPolicies,
+                context: {
+                    ...baseContext,
+                    rpcUrl,
+                },
+            });
+            if (!vincentAbility.precheck) {
+                console.log('No ability precheck defined - returning baseContext policy evaluation results', {
+                    rawAbilityParams,
+                    delegatorPkpEthAddress,
+                    rpcUrl,
+                });
+                if (!baseAbilityContext.policiesContext.allow) {
+                    return (0, resultCreators_2.createAbilityPrecheckResponseFailureNoResult)({
+                        context: baseAbilityContext,
+                    });
+                }
+                return (0, resultCreators_2.createAbilityPrecheckResponseSuccessNoResult)({
+                    context: baseAbilityContext,
+                });
+            }
+            console.log('Executing ability precheck');
+            const precheckResult = await vincentAbility.precheck({ abilityParams: parsedParams }, baseAbilityContext);
+            if ((0, typeGuards_1.isAbilityResponseSchemaValidationFailure)(precheckResult) ||
+                (0, typeGuards_1.isAbilityResponseRuntimeFailure)(precheckResult)) {
+                console.log('Detected runtime or schema validation error in abilityPrecheckResult - returning as-is:', JSON.stringify({
+                    isAbilityResponseRuntimeFailure: (0, typeGuards_1.isAbilityResponseRuntimeFailure)(precheckResult),
+                    isAbilityResponseSchemaValidationFailure: (0, typeGuards_1.isAbilityResponseSchemaValidationFailure)(precheckResult),
+                    precheckResult,
+                }, bigintReplacer));
+                // Runtime errors and schema validation errors will not have results; return them as-is.
+                return precheckResult;
+            }
+            console.log('precheckResult()', JSON.stringify(precheckResult, bigintReplacer));
+            return {
+                ...precheckResult,
+                context: baseAbilityContext,
+            };
+        },
+        async execute(rawAbilityParams, context) {
+            const parsedParams = (0, internal_1.validateOrFail)(rawAbilityParams, vincentAbility.abilityParamsSchema, 'execute', 'input');
+            if ((0, typeGuards_1.isAbilityResponseFailure)(parsedParams)) {
+                return {
+                    ...parsedParams,
+                    context,
+                };
+            }
+            const litNodeClient = await (0, getLitNodeClient_1.getLitNodeClientInstance)({ network });
+            const sessionSigs = await (0, generateVincentAbilitySessionSigs_1.generateVincentAbilitySessionSigs)({ ethersSigner, litNodeClient });
+            const result = await litNodeClient.executeJs({
+                ipfsId: ipfsCid,
+                sessionSigs,
+                jsParams: {
+                    abilityParams: parsedParams,
+                    context,
+                    vincentAbilityApiVersion,
+                },
+            });
+            const { success, response } = result;
+            console.log('executeResult - raw result from `litNodeClient.executeJs()', {
+                response,
+                success,
+            });
+            if (success !== true) {
+                return (0, resultCreators_1.createAbilityExecuteResponseFailureNoResult)({
+                    runtimeError: `Remote ability failed with unknown error: ${JSON.stringify(response, bigintReplacer, 2)}`,
+                });
+            }
+            let parsedResult = response;
+            if (typeof response === 'string') {
+                // lit-node-client returns a string if no signed data, even if the result could be JSON.parse'd :(
+                try {
+                    parsedResult = JSON.parse(response);
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    return (0, resultCreators_1.createAbilityExecuteResponseFailureNoResult)({
+                        runtimeError: `Remote ability failed with unknown error: ${JSON.stringify(response, bigintReplacer)}`,
+                    });
+                }
+            }
+            if (!(0, typeGuards_1.isRemoteVincentAbilityExecutionResult)(parsedResult)) {
+                console.log('Result from `executeJs` was valid JSON, but not a vincentAbilityExecutionResult', { parsedResult, success });
+                return (0, resultCreators_1.createAbilityExecuteResponseFailureNoResult)({
+                    runtimeError: `Remote ability failed with unknown error: ${JSON.stringify(parsedResult, bigintReplacer)}`,
+                });
+            }
+            const remoteVincentAbilityResult = parsedResult;
+            console.log('Parsed executeJs vincentAbilityExecutionResult:', JSON.stringify(parsedResult, bigintReplacer));
+            const { abilityContext, abilityExecutionResult } = remoteVincentAbilityResult;
+            if ((0, typeGuards_1.isAbilityResponseSchemaValidationFailure)(abilityExecutionResult) ||
+                (0, typeGuards_1.isAbilityResponseRuntimeFailure)(abilityExecutionResult)) {
+                console.log('Detected runtime or schema validation error in abilityExecutionResult - returning as-is:', JSON.stringify({
+                    isAbilityResponseRuntimeFailure: (0, typeGuards_1.isAbilityResponseRuntimeFailure)(abilityExecutionResult),
+                    isAbilityResponseSchemaValidationFailure: (0, typeGuards_1.isAbilityResponseSchemaValidationFailure)(abilityExecutionResult),
+                    abilityExecutionResult,
+                }, bigintReplacer));
+                // Runtime errors and schema validation errors will not have results; return them as-is.
+                return (0, resultCreators_1.createAbilityExecuteResponseFailureNoResult)({
+                    ...(abilityExecutionResult.runtimeError
+                        ? { runtimeError: abilityExecutionResult.runtimeError }
+                        : {}),
+                    ...(abilityExecutionResult.schemaValidationError
+                        ? { schemaValidationError: abilityExecutionResult.schemaValidationError }
+                        : {}),
+                    context: remoteVincentAbilityResult.abilityContext,
+                });
+            }
+            // Policy eval happens before `execute()` is ever called
+            // As a result, when policies return a `deny` result, there will be no ability result
+            // so we need to skip trying to run result through the success/fail schema logic
+            if (!abilityContext.policiesContext.allow) {
+                return (0, resultCreators_1.createAbilityExecuteResponseFailureNoResult)({
+                    context: abilityContext,
+                });
+            }
+            const resultSchemaDetails = (0, internal_1.getSchemaForAbilityResult)({
+                value: abilityExecutionResult,
+                successResultSchema: executeSuccessSchema,
+                failureResultSchema: executeFailSchema,
+            });
+            const { schemaToUse, parsedType } = resultSchemaDetails;
+            console.log(`Parsing ability result using the ${parsedType} Zod schema`);
+            // Parse returned result using appropriate execute zod schema
+            const executeResult = (0, internal_1.validateOrFail)(abilityExecutionResult.result, schemaToUse, 'execute', 'output');
+            console.log('Zod parse result:', executeResult);
+            if ((0, typeGuards_1.isAbilityResponseFailure)(executeResult)) {
+                // Parsing the result threw a zodError
+                return executeResult;
+            }
+            console.log('Raw abilityExecutionResult was:', abilityExecutionResult);
+            // We parsed the result -- it may be a success or a failure; return appropriately.
+            if ((0, typeGuards_1.isAbilityResponseFailure)(abilityExecutionResult)) {
+                return (0, resultCreators_1.createAbilityExecuteResponseFailure)({
+                    ...(abilityExecutionResult.runtimeError
+                        ? { runtimeError: abilityExecutionResult.runtimeError }
+                        : {}),
+                    ...(abilityExecutionResult.schemaValidationError
+                        ? { schemaValidationError: abilityExecutionResult.schemaValidationError }
+                        : {}),
+                    result: executeResult,
+                    context: remoteVincentAbilityResult.abilityContext,
+                });
+            }
+            const res = executeResult;
+            return (0, resultCreators_1.createAbilityExecuteResponseSuccess)({
+                result: res,
+                context: remoteVincentAbilityResult.abilityContext,
+            });
+        },
+    };
+}
+//# sourceMappingURL=vincentAbilityClient.js.map