@chainlink/cre-sdk 1.6.0-alpha.2 → 1.6.0-alpha.3

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

@@ -0,0 +1,186 @@
+import { create, fromJson } from '@bufbuild/protobuf';
+import { AccountAPTBalanceReplySchema, AccountAPTBalanceRequestSchema, AccountTransactionsReplySchema, AccountTransactionsRequestSchema, GasConfigSchema, TransactionByHashReplySchema, TransactionByHashRequestSchema, ViewReplySchema, ViewRequestSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../generated/capabilities/blockchain/aptos/v1alpha/client_pb';
+import { ReportResponseSchema, } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { Report } from '../../../../../sdk/report';
+import { hexToBytes } from '../../../../../sdk/utils/hex-utils';
+export function x_generatedCodeOnly_wrap_WriteCreReportRequest(input) {
+    return {
+        receiver: input.receiver,
+        gasConfig: input.gasConfig,
+        report: input.report !== undefined ? new Report(input.report) : undefined,
+        $report: true,
+    };
+}
+export function createWriteCreReportRequest(input) {
+    return {
+        receiver: hexToBytes(input.receiver),
+        gasConfig: input.gasConfig !== undefined ? fromJson(GasConfigSchema, input.gasConfig) : undefined,
+        report: input.report,
+        $report: true,
+    };
+}
+export function x_generatedCodeOnly_unwrap_WriteCreReportRequest(input) {
+    return create(WriteReportRequestSchema, {
+        receiver: input.receiver,
+        gasConfig: input.gasConfig,
+        report: input.report !== undefined ? input.report.x_generatedCodeOnly_unwrap() : undefined,
+    });
+}
+/**
+ * Client Capability
+ *
+ * Capability ID: aptos@1.0.0
+ * Capability Name: aptos
+ * Capability Version: 1.0.0
+ */
+export class ClientCapability {
+    ChainSelector;
+    /** The capability ID for this service */
+    static CAPABILITY_ID = 'aptos@1.0.0';
+    static CAPABILITY_NAME = 'aptos';
+    static CAPABILITY_VERSION = '1.0.0';
+    /** Available ChainSelector values */
+    static SUPPORTED_CHAIN_SELECTORS = {
+        'aptos-mainnet': 4741433654826277614n,
+        'aptos-testnet': 743186221051783445n,
+    };
+    constructor(ChainSelector) {
+        this.ChainSelector = ChainSelector;
+    }
+    accountAPTBalance(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(AccountAPTBalanceRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'AccountAPTBalance',
+            payload,
+            inputSchema: AccountAPTBalanceRequestSchema,
+            outputSchema: AccountAPTBalanceReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    view(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(ViewRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'View',
+            payload,
+            inputSchema: ViewRequestSchema,
+            outputSchema: ViewReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    transactionByHash(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(TransactionByHashRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'TransactionByHash',
+            payload,
+            inputSchema: TransactionByHashRequestSchema,
+            outputSchema: TransactionByHashReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    accountTransactions(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(AccountTransactionsRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'AccountTransactions',
+            payload,
+            inputSchema: AccountTransactionsRequestSchema,
+            outputSchema: AccountTransactionsReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    writeReport(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        // Check if it's a wrapped type by looking for the $report property
+        if (input.$report) {
+            // It's a wrapped type, unwrap it
+            payload = x_generatedCodeOnly_unwrap_WriteCreReportRequest(input);
+        }
+        else {
+            // It's wrapped JSON, convert using create function
+            payload = x_generatedCodeOnly_unwrap_WriteCreReportRequest(createWriteCreReportRequest(input));
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'WriteReport',
+            payload,
+            inputSchema: WriteReportRequestSchema,
+            outputSchema: WriteReportReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+}

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

@@ -0,0 +1,92 @@
+import { type Any } from '@bufbuild/protobuf/wkt';
+import { type AccountMeta, type AccountMetaJson, type ComputeConfig, type ComputeConfigJson, type FilterLogTriggerRequest, type FilterLogTriggerRequestJson, type GetAccountInfoWithOptsReply, type GetAccountInfoWithOptsRequest, type GetAccountInfoWithOptsRequestJson, type GetBalanceReply, type GetBalanceRequest, type GetBalanceRequestJson, type GetBlockReply, type GetBlockRequest, type GetBlockRequestJson, type GetFeeForMessageReply, type GetFeeForMessageRequest, type GetFeeForMessageRequestJson, type GetMultipleAccountsWithOptsReply, type GetMultipleAccountsWithOptsRequest, type GetMultipleAccountsWithOptsRequestJson, type GetSignatureStatusesReply, type GetSignatureStatusesRequest, type GetSignatureStatusesRequestJson, type GetSlotHeightReply, type GetSlotHeightRequest, type GetSlotHeightRequestJson, type GetTransactionReply, type GetTransactionRequest, type GetTransactionRequestJson, type Log, type WriteReportReply, type WriteReportRequest } from '../../../../../generated/capabilities/blockchain/solana/v1alpha/client_pb';
+import type { Runtime } from '../../../../../sdk';
+import { Report } from '../../../../../sdk/report';
+import type { Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
+export type WriteCreReportRequest = {
+    remainingAccounts: AccountMeta[];
+    receiver: Uint8Array;
+    computeConfig?: ComputeConfig;
+    report?: Report;
+    $report: true;
+};
+export type WriteCreReportRequestJson = {
+    remainingAccounts: AccountMetaJson[];
+    receiver: string;
+    computeConfig?: ComputeConfigJson;
+    report?: Report;
+};
+export declare function x_generatedCodeOnly_wrap_WriteCreReportRequest(input: WriteReportRequest): WriteCreReportRequest;
+export declare function createWriteCreReportRequest(input: WriteCreReportRequestJson): WriteCreReportRequest;
+export declare function x_generatedCodeOnly_unwrap_WriteCreReportRequest(input: WriteCreReportRequest): WriteReportRequest;
+/**
+ * Client Capability
+ *
+ * Capability ID: solana@1.0.0
+ * Capability Name: solana
+ * Capability Version: 1.0.0
+ */
+export declare class ClientCapability {
+    private readonly ChainSelector;
+    /** The capability ID for this service */
+    static readonly CAPABILITY_ID = "solana@1.0.0";
+    static readonly CAPABILITY_NAME = "solana";
+    static readonly CAPABILITY_VERSION = "1.0.0";
+    /** Available ChainSelector values */
+    static readonly SUPPORTED_CHAIN_SELECTORS: {
+        readonly 'solana-devnet': 16423721717087811551n;
+        readonly 'solana-mainnet': 124615329519749607n;
+        readonly 'solana-testnet': 6302590918974934319n;
+    };
+    constructor(ChainSelector: bigint);
+    getAccountInfoWithOpts(runtime: Runtime<unknown>, input: GetAccountInfoWithOptsRequest | GetAccountInfoWithOptsRequestJson): {
+        result: () => GetAccountInfoWithOptsReply;
+    };
+    getBalance(runtime: Runtime<unknown>, input: GetBalanceRequest | GetBalanceRequestJson): {
+        result: () => GetBalanceReply;
+    };
+    getBlock(runtime: Runtime<unknown>, input: GetBlockRequest | GetBlockRequestJson): {
+        result: () => GetBlockReply;
+    };
+    getFeeForMessage(runtime: Runtime<unknown>, input: GetFeeForMessageRequest | GetFeeForMessageRequestJson): {
+        result: () => GetFeeForMessageReply;
+    };
+    getMultipleAccountsWithOpts(runtime: Runtime<unknown>, input: GetMultipleAccountsWithOptsRequest | GetMultipleAccountsWithOptsRequestJson): {
+        result: () => GetMultipleAccountsWithOptsReply;
+    };
+    getSignatureStatuses(runtime: Runtime<unknown>, input: GetSignatureStatusesRequest | GetSignatureStatusesRequestJson): {
+        result: () => GetSignatureStatusesReply;
+    };
+    getSlotHeight(runtime: Runtime<unknown>, input: GetSlotHeightRequest | GetSlotHeightRequestJson): {
+        result: () => GetSlotHeightReply;
+    };
+    getTransaction(runtime: Runtime<unknown>, input: GetTransactionRequest | GetTransactionRequestJson): {
+        result: () => GetTransactionReply;
+    };
+    logTrigger(config: FilterLogTriggerRequestJson): ClientLogTrigger;
+    writeReport(runtime: Runtime<unknown>, input: WriteCreReportRequest | WriteCreReportRequestJson): {
+        result: () => WriteReportReply;
+    };
+}
+/**
+ * Trigger implementation for LogTrigger
+ */
+declare class ClientLogTrigger implements Trigger<Log, Log> {
+    private readonly _capabilityId;
+    private readonly _method;
+    private readonly ChainSelector;
+    readonly config: FilterLogTriggerRequest;
+    constructor(config: FilterLogTriggerRequest | FilterLogTriggerRequestJson, _capabilityId: string, _method: string, ChainSelector: bigint);
+    capabilityId(): string;
+    method(): string;
+    outputSchema(): import("@bufbuild/protobuf/codegenv2").GenMessage<Log, {
+        jsonType: import("../../../../../generated/capabilities/blockchain/solana/v1alpha/client_pb").LogJson;
+    }>;
+    configAsAny(): Any;
+    /**
+     * Transform the raw trigger output - override this method if needed
+     * Default implementation returns the raw output unchanged
+     */
+    adapt(rawOutput: Log): Log;
+}
+export {};

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

@@ -0,0 +1,343 @@
+import { create, fromJson } from '@bufbuild/protobuf';
+import { AnySchema, anyPack } from '@bufbuild/protobuf/wkt';
+import { AccountMetaSchema, ComputeConfigSchema, FilterLogTriggerRequestSchema, GetAccountInfoWithOptsReplySchema, GetAccountInfoWithOptsRequestSchema, GetBalanceReplySchema, GetBalanceRequestSchema, GetBlockReplySchema, GetBlockRequestSchema, GetFeeForMessageReplySchema, GetFeeForMessageRequestSchema, GetMultipleAccountsWithOptsReplySchema, GetMultipleAccountsWithOptsRequestSchema, GetSignatureStatusesReplySchema, GetSignatureStatusesRequestSchema, GetSlotHeightReplySchema, GetSlotHeightRequestSchema, GetTransactionReplySchema, GetTransactionRequestSchema, LogSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../generated/capabilities/blockchain/solana/v1alpha/client_pb';
+import { ReportResponseSchema, } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { Report } from '../../../../../sdk/report';
+import { hexToBytes } from '../../../../../sdk/utils/hex-utils';
+export function x_generatedCodeOnly_wrap_WriteCreReportRequest(input) {
+    return {
+        remainingAccounts: input.remainingAccounts,
+        receiver: input.receiver,
+        computeConfig: input.computeConfig,
+        report: input.report !== undefined ? new Report(input.report) : undefined,
+        $report: true,
+    };
+}
+export function createWriteCreReportRequest(input) {
+    return {
+        remainingAccounts: (input.remainingAccounts ?? []).map((v) => fromJson(AccountMetaSchema, v)),
+        receiver: hexToBytes(input.receiver),
+        computeConfig: input.computeConfig !== undefined
+            ? fromJson(ComputeConfigSchema, input.computeConfig)
+            : undefined,
+        report: input.report,
+        $report: true,
+    };
+}
+export function x_generatedCodeOnly_unwrap_WriteCreReportRequest(input) {
+    return create(WriteReportRequestSchema, {
+        remainingAccounts: input.remainingAccounts,
+        receiver: input.receiver,
+        computeConfig: input.computeConfig,
+        report: input.report !== undefined ? input.report.x_generatedCodeOnly_unwrap() : undefined,
+    });
+}
+/**
+ * Client Capability
+ *
+ * Capability ID: solana@1.0.0
+ * Capability Name: solana
+ * Capability Version: 1.0.0
+ */
+export class ClientCapability {
+    ChainSelector;
+    /** The capability ID for this service */
+    static CAPABILITY_ID = 'solana@1.0.0';
+    static CAPABILITY_NAME = 'solana';
+    static CAPABILITY_VERSION = '1.0.0';
+    /** Available ChainSelector values */
+    static SUPPORTED_CHAIN_SELECTORS = {
+        'solana-devnet': 16423721717087811551n,
+        'solana-mainnet': 124615329519749607n,
+        'solana-testnet': 6302590918974934319n,
+    };
+    constructor(ChainSelector) {
+        this.ChainSelector = ChainSelector;
+    }
+    getAccountInfoWithOpts(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(GetAccountInfoWithOptsRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'GetAccountInfoWithOpts',
+            payload,
+            inputSchema: GetAccountInfoWithOptsRequestSchema,
+            outputSchema: GetAccountInfoWithOptsReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    getBalance(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(GetBalanceRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'GetBalance',
+            payload,
+            inputSchema: GetBalanceRequestSchema,
+            outputSchema: GetBalanceReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    getBlock(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(GetBlockRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'GetBlock',
+            payload,
+            inputSchema: GetBlockRequestSchema,
+            outputSchema: GetBlockReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    getFeeForMessage(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(GetFeeForMessageRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'GetFeeForMessage',
+            payload,
+            inputSchema: GetFeeForMessageRequestSchema,
+            outputSchema: GetFeeForMessageReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    getMultipleAccountsWithOpts(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(GetMultipleAccountsWithOptsRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'GetMultipleAccountsWithOpts',
+            payload,
+            inputSchema: GetMultipleAccountsWithOptsRequestSchema,
+            outputSchema: GetMultipleAccountsWithOptsReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    getSignatureStatuses(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(GetSignatureStatusesRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'GetSignatureStatuses',
+            payload,
+            inputSchema: GetSignatureStatusesRequestSchema,
+            outputSchema: GetSignatureStatusesReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    getSlotHeight(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(GetSlotHeightRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'GetSlotHeight',
+            payload,
+            inputSchema: GetSlotHeightRequestSchema,
+            outputSchema: GetSlotHeightReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    getTransaction(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        if (input.$typeName) {
+            // It's the original protobuf type
+            payload = input;
+        }
+        else {
+            // It's regular JSON, convert using fromJson
+            payload = fromJson(GetTransactionRequestSchema, input);
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'GetTransaction',
+            payload,
+            inputSchema: GetTransactionRequestSchema,
+            outputSchema: GetTransactionReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+    logTrigger(config) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return new ClientLogTrigger(config, capabilityId, 'LogTrigger', this.ChainSelector);
+    }
+    writeReport(runtime, input) {
+        // Handle input conversion - unwrap if it's a wrapped type, convert from JSON if needed
+        let payload;
+        // Check if it's a wrapped type by looking for the $report property
+        if (input.$report) {
+            // It's a wrapped type, unwrap it
+            payload = x_generatedCodeOnly_unwrap_WriteCreReportRequest(input);
+        }
+        else {
+            // It's wrapped JSON, convert using create function
+            payload = x_generatedCodeOnly_unwrap_WriteCreReportRequest(createWriteCreReportRequest(input));
+        }
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        const capabilityResponse = runtime.callCapability({
+            capabilityId,
+            method: 'WriteReport',
+            payload,
+            inputSchema: WriteReportRequestSchema,
+            outputSchema: WriteReportReplySchema,
+        });
+        return {
+            result: () => {
+                const result = capabilityResponse.result();
+                return result;
+            },
+        };
+    }
+}
+/**
+ * Trigger implementation for LogTrigger
+ */
+class ClientLogTrigger {
+    _capabilityId;
+    _method;
+    ChainSelector;
+    config;
+    constructor(config, _capabilityId, _method, ChainSelector) {
+        this._capabilityId = _capabilityId;
+        this._method = _method;
+        this.ChainSelector = ChainSelector;
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        this.config = config.$typeName
+            ? config
+            : fromJson(FilterLogTriggerRequestSchema, config);
+    }
+    capabilityId() {
+        return this._capabilityId;
+    }
+    method() {
+        return this._method;
+    }
+    outputSchema() {
+        return LogSchema;
+    }
+    configAsAny() {
+        return anyPack(FilterLogTriggerRequestSchema, this.config);
+    }
+    /**
+     * Transform the raw trigger output - override this method if needed
+     * Default implementation returns the raw output unchanged
+     */
+    adapt(rawOutput) {
+        return rawOutput;
+    }
+}

package/dist/sdk/cre/index.d.ts

@@ -1,7 +1,9 @@
 /**
  * Public API for the CRE SDK.
  */
+import { ClientCapability as AptosClient } from '../../generated-sdk/capabilities/blockchain/aptos/v1alpha/client_sdk_gen';
 import { ClientCapability as EVMClient } from '../../generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen';
+import { ClientCapability as SolanaClient } from '../../generated-sdk/capabilities/blockchain/solana/v1alpha/client_sdk_gen';
 import { ClientCapability as ConfidentialHTTPClient } from '../../generated-sdk/capabilities/networking/confidentialhttp/v1alpha/client_sdk_gen';
 import { ClientCapability as HTTPClient } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
 import { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
@@ -12,7 +14,9 @@ import { CronCapability } from '../../generated-sdk/capabilities/scheduler/cron/
 export { type Log as EVMLog, TxStatus, } from '../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
 export type { Payload as HTTPPayload } from '../../generated/capabilities/networking/http/v1alpha/trigger_pb';
 export type { Payload as CronPayload } from '../../generated/capabilities/scheduler/cron/v1/trigger_pb';
+export { ClientCapability as AptosClient, type WriteCreReportRequest as AptosWriteCreReportRequest, type WriteCreReportRequestJson as AptosWriteCreReportRequestJson, } from '../../generated-sdk/capabilities/blockchain/aptos/v1alpha/client_sdk_gen';
 export { ClientCapability as EVMClient, type WriteCreReportRequest, type WriteCreReportRequestJson, } from '../../generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen';
+export { ClientCapability as SolanaClient, type WriteCreReportRequest as SolanaWriteCreReportRequest, type WriteCreReportRequestJson as SolanaWriteCreReportRequestJson, } from '../../generated-sdk/capabilities/blockchain/solana/v1alpha/client_sdk_gen';
 export { ClientCapability as ConfidentialHTTPClient } from '../../generated-sdk/capabilities/networking/confidentialhttp/v1alpha/client_sdk_gen';
 export { ClientCapability as HTTPClient, type SendRequester as HTTPSendRequester, } from '../../generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen';
 export { HTTPCapability } from '../../generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen';
@@ -26,6 +30,8 @@ export declare const cre: {
         ConfidentialHTTPClient: typeof ConfidentialHTTPClient;
         HTTPClient: typeof HTTPClient;
         EVMClient: typeof EVMClient;
+        AptosClient: typeof AptosClient;
+        SolanaClient: typeof SolanaClient;
     };
     handler: <TRawTriggerOutput extends import("@bufbuild/protobuf").Message<string>, TTriggerOutput, TConfig, TResult>(trigger: import("../utils/triggers/trigger-interface").Trigger<TRawTriggerOutput, TTriggerOutput>, fn: import("../workflow").HandlerFn<TConfig, TTriggerOutput, TResult>) => import("../workflow").HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult>;
 };