@chainlink/cre-sdk 1.15.0 → 1.17.0-alpha.1

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

@@ -1,7 +1,10 @@
-import { type AccountMeta, type AccountMetaJson, type ComputeConfig, type ComputeConfigJson, type WriteReportReply, type WriteReportRequest } from '../../../../../generated/capabilities/blockchain/solana/v1alpha/client_pb';
+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 GetProgramAccountsReply, type GetProgramAccountsRequest, type GetProgramAccountsRequestJson, 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 CapabilityRestrictionJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import type { Runtime } from '../../../../../sdk';
 import { Report } from '../../../../../sdk/report';
-import type { CapabilityInput } from '../../../../../sdk/utils/types/no-excess';
+import type { Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
+import type { CapabilityInput, NoExcess } from '../../../../../sdk/utils/types/no-excess';
 export type WriteCreReportRequest = {
     remainingAccounts: AccountMeta[];
     receiver: Uint8Array;
@@ -37,7 +40,71 @@ export declare class ClientCapability {
         readonly 'solana-mainnet': 124615329519749607n;
     };
     constructor(ChainSelector: bigint);
+    getAccountInfoWithOpts<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetAccountInfoWithOptsRequest, GetAccountInfoWithOptsRequestJson>): {
+        result: () => GetAccountInfoWithOptsReply;
+    };
+    getBalance<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetBalanceRequest, GetBalanceRequestJson>): {
+        result: () => GetBalanceReply;
+    };
+    getBlock<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetBlockRequest, GetBlockRequestJson>): {
+        result: () => GetBlockReply;
+    };
+    getFeeForMessage<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetFeeForMessageRequest, GetFeeForMessageRequestJson>): {
+        result: () => GetFeeForMessageReply;
+    };
+    getMultipleAccountsWithOpts<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetMultipleAccountsWithOptsRequest, GetMultipleAccountsWithOptsRequestJson>): {
+        result: () => GetMultipleAccountsWithOptsReply;
+    };
+    getProgramAccounts<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetProgramAccountsRequest, GetProgramAccountsRequestJson>): {
+        result: () => GetProgramAccountsReply;
+    };
+    getSignatureStatuses<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetSignatureStatusesRequest, GetSignatureStatusesRequestJson>): {
+        result: () => GetSignatureStatusesReply;
+    };
+    getSlotHeight<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetSlotHeightRequest, GetSlotHeightRequestJson>): {
+        result: () => GetSlotHeightReply;
+    };
+    getTransaction<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, GetTransactionRequest, GetTransactionRequestJson>): {
+        result: () => GetTransactionReply;
+    };
+    logTrigger<TConfig extends FilterLogTriggerRequestJson>(config: NoExcess<TConfig, FilterLogTriggerRequestJson>): ClientLogTrigger;
     writeReport<TInput>(runtime: Runtime<unknown>, input: CapabilityInput<TInput, 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 declare class ClientRestrictor {
+    private readonly ChainSelector;
+    constructor(ChainSelector: bigint);
+    limitGetAccountInfoWithOpts(maxCalls: number): CapabilityRestrictionJson;
+    limitGetBalance(maxCalls: number): CapabilityRestrictionJson;
+    limitGetBlock(maxCalls: number): CapabilityRestrictionJson;
+    limitGetFeeForMessage(maxCalls: number): CapabilityRestrictionJson;
+    limitGetMultipleAccountsWithOpts(maxCalls: number): CapabilityRestrictionJson;
+    limitGetProgramAccounts(maxCalls: number): CapabilityRestrictionJson;
+    limitGetSignatureStatuses(maxCalls: number): CapabilityRestrictionJson;
+    limitGetSlotHeight(maxCalls: number): CapabilityRestrictionJson;
+    limitGetTransaction(maxCalls: number): CapabilityRestrictionJson;
+    limitWriteReport(maxCalls: number): CapabilityRestrictionJson;
+}
+export {};

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

@@ -1,5 +1,6 @@
 import { create, fromJson } from '@bufbuild/protobuf';
-import { AccountMetaSchema, ComputeConfigSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../generated/capabilities/blockchain/solana/v1alpha/client_pb';
+import { AnySchema, anyPack } from '@bufbuild/protobuf/wkt';
+import { AccountMetaSchema, ComputeConfigSchema, FilterLogTriggerRequestSchema, GetAccountInfoWithOptsReplySchema, GetAccountInfoWithOptsRequestSchema, GetBalanceReplySchema, GetBalanceRequestSchema, GetBlockReplySchema, GetBlockRequestSchema, GetFeeForMessageReplySchema, GetFeeForMessageRequestSchema, GetMultipleAccountsWithOptsReplySchema, GetMultipleAccountsWithOptsRequestSchema, GetProgramAccountsReplySchema, GetProgramAccountsRequestSchema, 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';
@@ -52,6 +53,254 @@ export class ClientCapability {
     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;
+            },
+        };
+    }
+    getProgramAccounts(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(GetProgramAccountsRequestSchema, 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: 'GetProgramAccounts',
+            payload,
+            inputSchema: GetProgramAccountsRequestSchema,
+            outputSchema: GetProgramAccountsReplySchema,
+        });
+        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;
@@ -81,3 +330,156 @@ export class ClientCapability {
         };
     }
 }
+/**
+ * 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;
+    }
+}
+export class ClientRestrictor {
+    ChainSelector;
+    constructor(ChainSelector) {
+        this.ChainSelector = ChainSelector;
+    }
+    limitGetAccountInfoWithOpts(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetAccountInfoWithOpts',
+                maxCalls,
+            },
+        };
+    }
+    limitGetBalance(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetBalance',
+                maxCalls,
+            },
+        };
+    }
+    limitGetBlock(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetBlock',
+                maxCalls,
+            },
+        };
+    }
+    limitGetFeeForMessage(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetFeeForMessage',
+                maxCalls,
+            },
+        };
+    }
+    limitGetMultipleAccountsWithOpts(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetMultipleAccountsWithOpts',
+                maxCalls,
+            },
+        };
+    }
+    limitGetProgramAccounts(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetProgramAccounts',
+                maxCalls,
+            },
+        };
+    }
+    limitGetSignatureStatuses(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetSignatureStatuses',
+                maxCalls,
+            },
+        };
+    }
+    limitGetSlotHeight(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetSlotHeight',
+                maxCalls,
+            },
+        };
+    }
+    limitGetTransaction(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'GetTransaction',
+                maxCalls,
+            },
+        };
+    }
+    limitWriteReport(maxCalls) {
+        // Include all labels in capability ID for routing when specified
+        const capabilityId = `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.ChainSelector}@${ClientCapability.CAPABILITY_VERSION}`;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'WriteReport',
+                maxCalls,
+            },
+        };
+    }
+}

package/dist/generated-sdk/capabilities/internal/consensus/v1alpha/consensus_sdk_gen.d.ts

@@ -1,4 +1,4 @@
-import { type ReportRequest, type ReportRequestJson, type SimpleConsensusInputs, type SimpleConsensusInputsJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { type CapabilityRestrictionJson, type ReportRequest, type ReportRequestJson, type SimpleConsensusInputs, type SimpleConsensusInputsJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import { type Value } from '../../../../../generated/values/v1/values_pb';
 import type { Runtime } from '../../../../../sdk';
 import { Report } from '../../../../../sdk/report';
@@ -22,3 +22,7 @@ export declare class ConsensusCapability {
         result: () => Report;
     };
 }
+export declare class ConsensusRestrictor {
+    limitSimple(maxCalls: number): CapabilityRestrictionJson;
+    limitReport(maxCalls: number): CapabilityRestrictionJson;
+}

package/dist/generated-sdk/capabilities/internal/consensus/v1alpha/consensus_sdk_gen.js

@@ -68,3 +68,25 @@ export class ConsensusCapability {
         };
     }
 }
+export class ConsensusRestrictor {
+    limitSimple(maxCalls) {
+        const capabilityId = ConsensusCapability.CAPABILITY_ID;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'Simple',
+                maxCalls,
+            },
+        };
+    }
+    limitReport(maxCalls) {
+        const capabilityId = ConsensusCapability.CAPABILITY_ID;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'Report',
+                maxCalls,
+            },
+        };
+    }
+}

package/dist/generated-sdk/capabilities/networking/confidentialhttp/v1alpha/client_sdk_gen.d.ts

@@ -1,4 +1,5 @@
 import { type ConfidentialHTTPRequest, type ConfidentialHTTPRequestJson, type HTTPResponse } from '../../../../../generated/capabilities/networking/confidentialhttp/v1alpha/client_pb';
+import type { CapabilityRestrictionJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
 import type { Runtime } from '../../../../../sdk';
 import type { CapabilityInput } from '../../../../../sdk/utils/types/no-excess';
 /**
@@ -17,3 +18,6 @@ export declare class ClientCapability {
         result: () => HTTPResponse;
     };
 }
+export declare class ClientRestrictor {
+    limitSendRequest(maxCalls: number): CapabilityRestrictionJson;
+}

package/dist/generated-sdk/capabilities/networking/confidentialhttp/v1alpha/client_sdk_gen.js

@@ -41,3 +41,15 @@ export class ClientCapability {
         };
     }
 }
+export class ClientRestrictor {
+    limitSendRequest(maxCalls) {
+        const capabilityId = ClientCapability.CAPABILITY_ID;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'SendRequest',
+                maxCalls,
+            },
+        };
+    }
+}

package/dist/generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen.d.ts

@@ -1,5 +1,6 @@
 import { type Request, type RequestJson, type Response } from '../../../../../generated/capabilities/networking/http/v1alpha/client_pb';
-import type { NodeRuntime, Runtime } from '../../../../../sdk';
+import type { CapabilityRestrictionJson } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import type { NodeRuntime, Runtime, TeeRuntime } from '../../../../../sdk';
 import type { ConsensusAggregation, PrimitiveTypes, UnwrapOptions } from '../../../../../sdk/utils';
 import type { CapabilityInput } from '../../../../../sdk/utils/types/no-excess';
 export declare class SendRequester {
@@ -22,12 +23,21 @@ export declare class ClientCapability {
     static readonly CAPABILITY_ID = "http-actions@1.0.0-alpha";
     static readonly CAPABILITY_NAME = "http-actions";
     static readonly CAPABILITY_VERSION = "1.0.0-alpha";
+    sendRequest<TInput>(runtime: TeeRuntime<unknown>, input: CapabilityInput<TInput, Request, RequestJson>): {
+        result: () => Response;
+    };
     sendRequest<TInput>(runtime: NodeRuntime<unknown>, input: CapabilityInput<TInput, Request, RequestJson>): {
         result: () => Response;
     };
+    sendRequest<TInput>(runtime: NodeRuntime<unknown> | TeeRuntime<unknown>, input: CapabilityInput<TInput, Request, RequestJson>): {
+        result: () => Response;
+    };
     sendRequest<TArgs extends unknown[], TOutput>(runtime: Runtime<unknown>, fn: (sendRequester: SendRequester, ...args: TArgs) => TOutput, consensusAggregation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => {
         result: () => TOutput;
     };
     private sendRequestCallHelper;
     private sendRequestSugarHelper;
 }
+export declare class ClientRestrictor {
+    limitSendRequest(maxCalls: number): CapabilityRestrictionJson;
+}

package/dist/generated-sdk/capabilities/networking/http/v1alpha/client_sdk_gen.js

@@ -68,3 +68,15 @@ export class ClientCapability {
         return runtime.runInNodeMode(wrappedFn, consensusAggregation, unwrapOptions);
     }
 }
+export class ClientRestrictor {
+    limitSendRequest(maxCalls) {
+        const capabilityId = ClientCapability.CAPABILITY_ID;
+        return {
+            method: {
+                id: capabilityId,
+                method: 'SendRequest',
+                maxCalls,
+            },
+        };
+    }
+}

package/dist/generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen.d.ts

@@ -36,4 +36,6 @@ declare class HTTPTrigger implements Trigger<Payload, Payload> {
      */
     adapt(rawOutput: Payload): Payload;
 }
+export declare class HTTPRestrictor {
+}
 export {};

package/dist/generated-sdk/capabilities/networking/http/v1alpha/http_sdk_gen.js

@@ -53,3 +53,5 @@ class HTTPTrigger {
         return rawOutput;
     }
 }
+export class HTTPRestrictor {
+}

package/dist/generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen.d.ts

@@ -36,4 +36,6 @@ declare class CronTrigger implements Trigger<Payload, Payload> {
      */
     adapt(rawOutput: Payload): Payload;
 }
+export declare class CronRestrictor {
+}
 export {};

package/dist/generated-sdk/capabilities/scheduler/cron/v1/cron_sdk_gen.js

@@ -53,3 +53,5 @@ class CronTrigger {
         return rawOutput;
     }
 }
+export class CronRestrictor {
+}