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

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

@@ -1,22 +1,18 @@
 import { type Any, type Empty } from '@bufbuild/protobuf/wkt';
 import { type BalanceAtReply, type BalanceAtRequest, type BalanceAtRequestJson, type CallContractReply, type CallContractRequest, type CallContractRequestJson, type EstimateGasReply, type EstimateGasRequest, type EstimateGasRequestJson, type FilterLogsReply, type FilterLogsRequest, type FilterLogsRequestJson, type FilterLogTriggerRequest, type FilterLogTriggerRequestJson, type GetTransactionByHashReply, type GetTransactionByHashRequest, type GetTransactionByHashRequestJson, type GetTransactionReceiptReply, type GetTransactionReceiptRequest, type GetTransactionReceiptRequestJson, type HeaderByNumberReply, type HeaderByNumberRequest, type HeaderByNumberRequestJson, type Log, type RegisterLogTrackingRequest, type RegisterLogTrackingRequestJson, type UnregisterLogTrackingRequest, type UnregisterLogTrackingRequestJson, type WriteReportReply, type WriteReportRequest, type WriteReportRequestJson } from '../../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
-import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import type { Runtime } from '../../../../../sdk/runtime';
 import { type Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
 /**
  * Client Capability
  *
  * Capability ID: evm@1.0.0
- * Default Mode: Mode.DON
  * Capability Name: evm
  * Capability Version: 1.0.0
  */
 export declare class ClientCapability {
-    private readonly mode;
     private readonly chainSelector?;
     /** The capability ID for this service */
     static readonly CAPABILITY_ID = "evm@1.0.0";
-    /** The default execution mode for this capability */
-    static readonly DEFAULT_MODE = Mode.DON;
     static readonly CAPABILITY_NAME = "evm";
     static readonly CAPABILITY_VERSION = "1.0.0";
     /** Available chain selectors */
@@ -35,48 +31,47 @@ export declare class ClientCapability {
         readonly 'polygon-mainnet': 4051577828743386545n;
         readonly 'polygon-testnet-amoy': 16281711391670634445n;
     };
-    constructor(mode?: Mode, chainSelector?: bigint | undefined);
-    callContract(input: CallContractRequest | CallContractRequestJson): {
-        result: () => Promise<CallContractReply>;
+    constructor(chainSelector?: bigint | undefined);
+    callContract(runtime: Runtime<unknown>, input: CallContractRequest | CallContractRequestJson): {
+        result: () => CallContractReply;
     };
-    filterLogs(input: FilterLogsRequest | FilterLogsRequestJson): {
-        result: () => Promise<FilterLogsReply>;
+    filterLogs(runtime: Runtime<unknown>, input: FilterLogsRequest | FilterLogsRequestJson): {
+        result: () => FilterLogsReply;
     };
-    balanceAt(input: BalanceAtRequest | BalanceAtRequestJson): {
-        result: () => Promise<BalanceAtReply>;
+    balanceAt(runtime: Runtime<unknown>, input: BalanceAtRequest | BalanceAtRequestJson): {
+        result: () => BalanceAtReply;
     };
-    estimateGas(input: EstimateGasRequest | EstimateGasRequestJson): {
-        result: () => Promise<EstimateGasReply>;
+    estimateGas(runtime: Runtime<unknown>, input: EstimateGasRequest | EstimateGasRequestJson): {
+        result: () => EstimateGasReply;
     };
-    getTransactionByHash(input: GetTransactionByHashRequest | GetTransactionByHashRequestJson): {
-        result: () => Promise<GetTransactionByHashReply>;
+    getTransactionByHash(runtime: Runtime<unknown>, input: GetTransactionByHashRequest | GetTransactionByHashRequestJson): {
+        result: () => GetTransactionByHashReply;
     };
-    getTransactionReceipt(input: GetTransactionReceiptRequest | GetTransactionReceiptRequestJson): {
-        result: () => Promise<GetTransactionReceiptReply>;
+    getTransactionReceipt(runtime: Runtime<unknown>, input: GetTransactionReceiptRequest | GetTransactionReceiptRequestJson): {
+        result: () => GetTransactionReceiptReply;
     };
-    headerByNumber(input: HeaderByNumberRequest | HeaderByNumberRequestJson): {
-        result: () => Promise<HeaderByNumberReply>;
+    headerByNumber(runtime: Runtime<unknown>, input: HeaderByNumberRequest | HeaderByNumberRequestJson): {
+        result: () => HeaderByNumberReply;
     };
-    registerLogTracking(input: RegisterLogTrackingRequest | RegisterLogTrackingRequestJson): {
-        result: () => Promise<Empty>;
+    registerLogTracking(runtime: Runtime<unknown>, input: RegisterLogTrackingRequest | RegisterLogTrackingRequestJson): {
+        result: () => Empty;
     };
-    unregisterLogTracking(input: UnregisterLogTrackingRequest | UnregisterLogTrackingRequestJson): {
-        result: () => Promise<Empty>;
+    unregisterLogTracking(runtime: Runtime<unknown>, input: UnregisterLogTrackingRequest | UnregisterLogTrackingRequestJson): {
+        result: () => Empty;
     };
     logTrigger(config: FilterLogTriggerRequestJson): ClientLogTrigger;
-    writeReport(input: WriteReportRequest | WriteReportRequestJson): {
-        result: () => Promise<WriteReportReply>;
+    writeReport(runtime: Runtime<unknown>, input: WriteReportRequest | WriteReportRequestJson): {
+        result: () => WriteReportReply;
     };
 }
 /**
  * Trigger implementation for LogTrigger
  */
 declare class ClientLogTrigger implements Trigger<Log, Log> {
-    readonly mode: Mode;
     private readonly _capabilityId;
     private readonly _method;
     readonly config: FilterLogTriggerRequest;
-    constructor(mode: Mode, config: FilterLogTriggerRequest | FilterLogTriggerRequestJson, _capabilityId: string, _method: string);
+    constructor(config: FilterLogTriggerRequest | FilterLogTriggerRequestJson, _capabilityId: string, _method: string);
     capabilityId(): string;
     method(): string;
     outputSchema(): import("@bufbuild/protobuf/codegenv2").GenMessage<Log, {

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

@@ -1,26 +1,18 @@
-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/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 +31,223 @@ 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) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    callContract(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    filterLogs(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    filterLogs(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    balanceAt(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    balanceAt(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    estimateGas(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    estimateGas(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    getTransactionByHash(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    getTransactionByHash(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    getTransactionReceipt(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    getTransactionReceipt(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    headerByNumber(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    headerByNumber(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    registerLogTracking(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    registerLogTracking(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
-    unregisterLogTracking(input) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    unregisterLogTracking(runtime, input) {
+        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);
+            result: () => {
+                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) {
-        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
-        const value = input.$typeName
+    writeReport(runtime, input) {
+        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);
+            result: () => {
+                return capabilityResponse.result();
             },
         };
     }
@@ -451,12 +256,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 +277,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