@chainlink/cre-sdk 0.0.1-alpha → 0.0.2-alpha

package/dist/generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen.js

@@ -1,26 +1,19 @@
-import { create, fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
-import { AnySchema, EmptySchema } from '@bufbuild/protobuf/wkt';
+import { create, fromJson } from '@bufbuild/protobuf';
+import { AnySchema, anyPack, EmptySchema } from '@bufbuild/protobuf/wkt';
 import { BalanceAtReplySchema, BalanceAtRequestSchema, CallContractReplySchema, CallContractRequestSchema, EstimateGasReplySchema, EstimateGasRequestSchema, FilterLogsReplySchema, FilterLogsRequestSchema, FilterLogTriggerRequestSchema, GetTransactionByHashReplySchema, GetTransactionByHashRequestSchema, GetTransactionReceiptReplySchema, GetTransactionReceiptRequestSchema, HeaderByNumberReplySchema, HeaderByNumberRequestSchema, LogSchema, RegisterLogTrackingRequestSchema, UnregisterLogTrackingRequestSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
-import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
-import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
+import {} from '../../../../../sdk/runtime';
 import {} from '../../../../../sdk/utils/triggers/trigger-interface';
-import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
 /**
  * Client Capability
  *
  * Capability ID: evm@1.0.0
- * Default Mode: Mode.DON
  * Capability Name: evm
  * Capability Version: 1.0.0
  */
 export class ClientCapability {
-    mode;
     chainSelector;
     /** The capability ID for this service */
     static CAPABILITY_ID = 'evm@1.0.0';
-    /** The default execution mode for this capability */
-    static DEFAULT_MODE = Mode.DON;
     static CAPABILITY_NAME = 'evm';
     static CAPABILITY_VERSION = '1.0.0';
     /** Available chain selectors */
@@ -39,410 +32,233 @@ export class ClientCapability {
         'polygon-mainnet': 4051577828743386545n,
         'polygon-testnet-amoy': 16281711391670634445n,
     };
-    constructor(mode = ClientCapability.DEFAULT_MODE, chainSelector) {
-        this.mode = mode;
+    constructor(chainSelector) {
         this.chainSelector = chainSelector;
     }
-    callContract(input) {
+    callContract(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(CallContractRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(CallContractRequestSchema),
-            value: toBinary(CallContractRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'CallContract',
-            mode: this.mode,
             payload,
+            inputSchema: CallContractRequestSchema,
+            outputSchema: CallContractReplySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'CallContract',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'CallContract',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(CallContractReplySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
-    filterLogs(input) {
+    filterLogs(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(FilterLogsRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(FilterLogsRequestSchema),
-            value: toBinary(FilterLogsRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'FilterLogs',
-            mode: this.mode,
             payload,
+            inputSchema: FilterLogsRequestSchema,
+            outputSchema: FilterLogsReplySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'FilterLogs',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'FilterLogs',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(FilterLogsReplySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
-    balanceAt(input) {
+    balanceAt(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(BalanceAtRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(BalanceAtRequestSchema),
-            value: toBinary(BalanceAtRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'BalanceAt',
-            mode: this.mode,
             payload,
+            inputSchema: BalanceAtRequestSchema,
+            outputSchema: BalanceAtReplySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'BalanceAt',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'BalanceAt',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(BalanceAtReplySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
-    estimateGas(input) {
+    estimateGas(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(EstimateGasRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(EstimateGasRequestSchema),
-            value: toBinary(EstimateGasRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'EstimateGas',
-            mode: this.mode,
             payload,
+            inputSchema: EstimateGasRequestSchema,
+            outputSchema: EstimateGasReplySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'EstimateGas',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'EstimateGas',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(EstimateGasReplySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
-    getTransactionByHash(input) {
+    getTransactionByHash(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(GetTransactionByHashRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(GetTransactionByHashRequestSchema),
-            value: toBinary(GetTransactionByHashRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'GetTransactionByHash',
-            mode: this.mode,
             payload,
+            inputSchema: GetTransactionByHashRequestSchema,
+            outputSchema: GetTransactionByHashReplySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'GetTransactionByHash',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'GetTransactionByHash',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(GetTransactionByHashReplySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
-    getTransactionReceipt(input) {
+    getTransactionReceipt(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(GetTransactionReceiptRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(GetTransactionReceiptRequestSchema),
-            value: toBinary(GetTransactionReceiptRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'GetTransactionReceipt',
-            mode: this.mode,
             payload,
+            inputSchema: GetTransactionReceiptRequestSchema,
+            outputSchema: GetTransactionReceiptReplySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'GetTransactionReceipt',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'GetTransactionReceipt',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(GetTransactionReceiptReplySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
-    headerByNumber(input) {
+    headerByNumber(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(HeaderByNumberRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(HeaderByNumberRequestSchema),
-            value: toBinary(HeaderByNumberRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'HeaderByNumber',
-            mode: this.mode,
             payload,
+            inputSchema: HeaderByNumberRequestSchema,
+            outputSchema: HeaderByNumberReplySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'HeaderByNumber',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'HeaderByNumber',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(HeaderByNumberReplySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
-    registerLogTracking(input) {
+    registerLogTracking(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(RegisterLogTrackingRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(RegisterLogTrackingRequestSchema),
-            value: toBinary(RegisterLogTrackingRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'RegisterLogTracking',
-            mode: this.mode,
             payload,
+            inputSchema: RegisterLogTrackingRequestSchema,
+            outputSchema: EmptySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'RegisterLogTracking',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'RegisterLogTracking',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(EmptySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
-    unregisterLogTracking(input) {
+    unregisterLogTracking(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(UnregisterLogTrackingRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(UnregisterLogTrackingRequestSchema),
-            value: toBinary(UnregisterLogTrackingRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'UnregisterLogTracking',
-            mode: this.mode,
             payload,
+            inputSchema: UnregisterLogTrackingRequestSchema,
+            outputSchema: EmptySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'UnregisterLogTracking',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'UnregisterLogTracking',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(EmptySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
     logTrigger(config) {
-        return new ClientLogTrigger(this.mode, config, ClientCapability.CAPABILITY_ID, 'LogTrigger');
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        return new ClientLogTrigger(config, capabilityId, 'LogTrigger');
     }
-    writeReport(input) {
+    writeReport(runtime, input) {
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+        const payload = input.$typeName
             ? input
             : fromJson(WriteReportRequestSchema, input);
-        const payload = {
-            typeUrl: getTypeUrl(WriteReportRequestSchema),
-            value: toBinary(WriteReportRequestSchema, value),
-        };
         // Include chainSelector in capability ID for routing when specified
         const capabilityId = this.chainSelector
             ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
             : ClientCapability.CAPABILITY_ID;
-        const capabilityResponse = callCapability({
+        const capabilityResponse = runtime.callCapability({
             capabilityId,
             method: 'WriteReport',
-            mode: this.mode,
             payload,
+            inputSchema: WriteReportRequestSchema,
+            outputSchema: WriteReportReplySchema,
         });
         return {
             result: async () => {
-                const { response } = await capabilityResponse.result();
-                if (response.case === 'error') {
-                    throw new CapabilityError(response.value, {
-                        capabilityId,
-                        method: 'WriteReport',
-                        mode: this.mode,
-                    });
-                }
-                if (response.case !== 'payload') {
-                    throw new CapabilityError('No payload in response', {
-                        capabilityId,
-                        method: 'WriteReport',
-                        mode: this.mode,
-                    });
-                }
-                return fromBinary(WriteReportReplySchema, response.value.value);
+                return capabilityResponse.result();
             },
         };
     }
@@ -451,12 +267,10 @@ export class ClientCapability {
  * Trigger implementation for LogTrigger
  */
 class ClientLogTrigger {
-    mode;
     _capabilityId;
     _method;
     config;
-    constructor(mode, config, _capabilityId, _method) {
-        this.mode = mode;
+    constructor(config, _capabilityId, _method) {
         this._capabilityId = _capabilityId;
         this._method = _method;
         // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
@@ -474,10 +288,7 @@ class ClientLogTrigger {
         return LogSchema;
     }
     configAsAny() {
-        return create(AnySchema, {
-            typeUrl: getTypeUrl(FilterLogTriggerRequestSchema),
-            value: toBinary(FilterLogTriggerRequestSchema, this.config),
-        });
+        return anyPack(FilterLogTriggerRequestSchema, this.config);
     }
     /**
      * Transform the raw trigger output - override this method if needed

package/dist/generated-sdk/capabilities/internal/actionandtrigger/v1/basic_sdk_gen.d.ts

@@ -1,25 +1,21 @@
 import { type Any } from '@bufbuild/protobuf/wkt';
 import { type Config, type ConfigJson, type Input, type InputJson, type Output, type TriggerEvent } from '../../../../../generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { type Runtime } from '../../../../../sdk/runtime';
 import { type Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * Basic Capability
  *
  * Capability ID: basic-test-action-trigger@1.0.0
- * Default Mode: Mode.DON
  * Capability Name: basic-test-action-trigger
  * Capability Version: 1.0.0
  */
 export declare class BasicCapability {
-    private readonly mode;
     /** The capability ID for this service */
     static readonly CAPABILITY_ID = "basic-test-action-trigger@1.0.0";
-    /** The default execution mode for this capability */
-    static readonly DEFAULT_MODE = Mode.DON;
     static readonly CAPABILITY_NAME = "basic-test-action-trigger";
     static readonly CAPABILITY_VERSION = "1.0.0";
-    constructor(mode?: Mode);
-    action(input: Input | InputJson): {
+    constructor();
+    action(runtime: Runtime<any>, input: Input | InputJson): {
         result: () => Promise<Output>;
     };
     trigger(config: ConfigJson): BasicTrigger;
@@ -28,11 +24,10 @@ export declare class BasicCapability {
  * Trigger implementation for Trigger
  */
 declare class BasicTrigger implements Trigger<TriggerEvent, TriggerEvent> {
-    readonly mode: Mode;
     private readonly _capabilityId;
     private readonly _method;
     readonly config: Config;
-    constructor(mode: Mode, config: Config | ConfigJson, _capabilityId: string, _method: string);
+    constructor(config: Config | ConfigJson, _capabilityId: string, _method: string);
     capabilityId(): string;
     method(): string;
     outputSchema(): import("@bufbuild/protobuf/codegenv2").GenMessage<TriggerEvent, {