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

package/dist/sdk/report.js

@@ -1,12 +1,484 @@
-import { fromJson } from '@bufbuild/protobuf';
-import { ReportResponseSchema, } from '../generated/sdk/v1alpha/sdk_pb';
+import { create, fromJson } from '@bufbuild/protobuf';
+import { BinaryReader, WireType } from '@bufbuild/protobuf/wire';
+import { AnySchema } from '@bufbuild/protobuf/wkt';
+import { AttributedSignatureSchema, AwaitCapabilitiesRequestSchema, CapabilityRequestSchema, ReportResponseSchema, } from '../generated/sdk/v1alpha/sdk_pb';
+import { concatHex, getAddress, hexToBytes, keccak256, recoverAddress, toHex } from 'viem';
+import { productionEnvironment } from './don-info';
+import { DuplicateSignerError, NullReportError, ParseSignatureError, RawReportTooShortError, RecoverSignerError, UnknownSignerError, WrongSignatureCountError, } from './errors';
+import { donInfoCache } from './report-internals';
+const GET_DON_SELECTOR = new Uint8Array([0x23, 0x53, 0x74, 0x05]);
+const GET_NODES_BY_P2P_IDS_SELECTOR = new Uint8Array([0x05, 0xa5, 0x19, 0x66]);
+function cacheKey(env, donID) {
+    return `${env.chainSelector.toString()}:${donID}`;
+}
+function normalizeRegistryHex(addr) {
+    return addr
+        .trim()
+        .replace(/^0[xX]/, '')
+        .toLowerCase();
+}
+function isProductionEnvironmentForReport(env) {
+    const pe = productionEnvironment();
+    return (env.chainSelector === pe.chainSelector &&
+        normalizeRegistryHex(env.registryAddress) === normalizeRegistryHex(pe.registryAddress));
+}
+function decodeRegistryAddress(registryAddress) {
+    const hex = normalizeRegistryHex(registryAddress);
+    if (hex.length !== 40) {
+        throw new Error(`invalid registry address ${JSON.stringify(registryAddress)}`);
+    }
+    return hexToBytes(`0x${hex}`);
+}
+function padUint256(v) {
+    const n = typeof v === 'bigint' ? v : BigInt(v);
+    const b = new Uint8Array(32);
+    const view = new DataView(b.buffer);
+    view.setBigUint64(24, n, false);
+    return b;
+}
+function bytesToBigIntBE(word) {
+    let x = 0n;
+    for (let i = 0; i < word.length; i++) {
+        x = (x << 8n) | BigInt(word[i]);
+    }
+    return x;
+}
+function readUint256AsInt(word) {
+    const b = bytesToBigIntBE(word);
+    if (b > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error('ABI uint256 value too large for Number');
+    }
+    return Number(b);
+}
+function protoVarint(v) {
+    const out = [];
+    let n = typeof v === 'bigint' ? v : BigInt(v);
+    while (n >= 128n) {
+        out.push(Number(n & 0x7fn) | 0x80);
+        n >>= 7n;
+    }
+    out.push(Number(n));
+    return out;
+}
+function protoTag(field, wireType) {
+    return protoVarint((field << 3) | wireType);
+}
+function protoLenBytes(data) {
+    return [...protoVarint(data.length), ...data];
+}
+function buildCallContractRequestBytes(registryAddr, callData) {
+    const callMsg = new Uint8Array([
+        ...protoTag(2, 2),
+        ...protoLenBytes(registryAddr),
+        ...protoTag(3, 2),
+        ...protoLenBytes(callData),
+    ]);
+    const bigInt = new Uint8Array([
+        ...protoTag(1, 2),
+        ...protoLenBytes(new Uint8Array([0x03])),
+        ...protoTag(2, 0),
+        ...protoVarint(0xffffffffffffffffn),
+    ]);
+    return new Uint8Array([
+        ...protoTag(2, 2),
+        ...protoLenBytes(bigInt),
+        ...protoTag(1, 2),
+        ...protoLenBytes(callMsg),
+    ]);
+}
+function decodeCallContractReplyData(bytes) {
+    const reader = new BinaryReader(bytes);
+    while (reader.pos < reader.len) {
+        const [fieldNo, wireType] = reader.tag();
+        if (fieldNo === 1 && wireType === WireType.LengthDelimited) {
+            return reader.bytes();
+        }
+        reader.skip(wireType);
+    }
+    throw new Error('data field not found in CallContractReply');
+}
+const CALL_CONTRACT_REQUEST_TYPE_URL = 'type.googleapis.com/capabilities.blockchain.evm.v1alpha.CallContractRequest';
+function callContract(runtime, capID, registryAddr, callData) {
+    const reqBytes = buildCallContractRequestBytes(registryAddr, callData);
+    const anyPayload = create(AnySchema, {
+        typeUrl: CALL_CONTRACT_REQUEST_TYPE_URL,
+        value: reqBytes,
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: intentional bypass of typed callCapability to avoid EVM schema imports
+    const rt = runtime;
+    const callbackId = rt.nextCallId++;
+    const req = create(CapabilityRequestSchema, {
+        id: capID,
+        method: 'CallContract',
+        payload: anyPayload,
+        callbackId,
+    });
+    if (!rt.helpers.call(req)) {
+        throw new Error(`EVM capability '${capID}' not found`);
+    }
+    // Must use create() — the real WASM bridge serializes this as a protobuf message and
+    // requires a proper typed message (with $typeName). A plain { ids: [...] } object works
+    // in the test runtime but silently breaks in simulation.
+    const awaitResp = rt.helpers.await(create(AwaitCapabilitiesRequestSchema, { ids: [callbackId] }), rt.maxResponseSize);
+    const capResp = awaitResp?.responses?.[callbackId];
+    if (!capResp) {
+        throw new Error(`no response from EVM capability '${capID}'`);
+    }
+    const response = capResp.response;
+    if (response.case === 'error') {
+        throw new Error(response.value);
+    }
+    if (response.case !== 'payload') {
+        throw new Error(`unexpected response '${response.case}' from EVM capability '${capID}'`);
+    }
+    return decodeCallContractReplyData(response.value.value);
+}
+function encodeGetDONCalldata(donID) {
+    const padded = new Uint8Array(32);
+    const view = new DataView(padded.buffer);
+    view.setUint32(28, donID >>> 0, false);
+    const out = new Uint8Array(4 + 32);
+    out.set(GET_DON_SELECTOR, 0);
+    out.set(padded, 4);
+    return out;
+}
+function concatBytes(parts) {
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const r = new Uint8Array(total);
+    let o = 0;
+    for (const p of parts) {
+        r.set(p, o);
+        o += p.length;
+    }
+    return r;
+}
+function encodeGetNodesByP2PIdsCalldata(p2pIds) {
+    const chunks = [
+        GET_NODES_BY_P2P_IDS_SELECTOR,
+        padUint256(32),
+        padUint256(p2pIds.length),
+    ];
+    for (const id of p2pIds) {
+        if (id.length !== 32) {
+            throw new Error('p2p id must be 32 bytes');
+        }
+        chunks.push(new Uint8Array(id));
+    }
+    return concatBytes(chunks);
+}
+const NODE_TUPLE_HEAD_SIZE = 288;
+function fetchDONInfo(runtime, env, donID) {
+    const key = cacheKey(env, donID);
+    const hit = donInfoCache.get(key);
+    if (hit) {
+        return hit;
+    }
+    const registryAddr = decodeRegistryAddress(env.registryAddress);
+    const capID = `evm:ChainSelector:${env.chainSelector.toString()}@1.0.0`;
+    const getDONABI = callContract(runtime, capID, registryAddr, encodeGetDONCalldata(donID));
+    if (getDONABI.length < 224) {
+        throw new Error(`getDON ABI response too short: ${getDONABI.length} bytes`);
+    }
+    const f = readUint256AsInt(getDONABI.subarray(96, 128));
+    const tupleStart = 32;
+    const nodeP2PIdsPtr = readUint256AsInt(getDONABI.subarray(192, 224));
+    const nodeCountOff = tupleStart + nodeP2PIdsPtr;
+    if (nodeCountOff + 32 > getDONABI.length) {
+        throw new Error('getDON ABI: nodeP2PIds pointer out of range');
+    }
+    const nodeCount = readUint256AsInt(getDONABI.subarray(nodeCountOff, nodeCountOff + 32));
+    if (nodeCountOff + 32 + nodeCount * 32 > getDONABI.length) {
+        throw new Error('getDON ABI: nodeP2PIds data out of range');
+    }
+    const nodeP2PIds = [];
+    for (let i = 0; i < nodeCount; i++) {
+        const start = nodeCountOff + 32 + i * 32;
+        nodeP2PIds.push(getDONABI.subarray(start, start + 32));
+    }
+    if (nodeCount === 0) {
+        const info = { f, signers: new Map() };
+        donInfoCache.set(key, info);
+        return info;
+    }
+    const getNodesABI = callContract(runtime, capID, registryAddr, encodeGetNodesByP2PIdsCalldata(nodeP2PIds));
+    if (getNodesABI.length < 64) {
+        throw new Error(`getNodesByP2PIds ABI response too short: ${getNodesABI.length} bytes`);
+    }
+    const outerPtr = readUint256AsInt(getNodesABI.subarray(0, 32));
+    if (outerPtr + 32 > getNodesABI.length) {
+        throw new Error('getNodesByP2PIds ABI: outer pointer out of range');
+    }
+    const returnedCount = readUint256AsInt(getNodesABI.subarray(outerPtr, outerPtr + 32));
+    const signers = new Map();
+    for (let i = 0; i < returnedCount; i++) {
+        const elemPtrOff = outerPtr + 32 + i * 32;
+        if (elemPtrOff + 32 > getNodesABI.length) {
+            break;
+        }
+        const elemPtr = readUint256AsInt(getNodesABI.subarray(elemPtrOff, elemPtrOff + 32));
+        const tupleBase = outerPtr + 32 + elemPtr;
+        if (tupleBase + NODE_TUPLE_HEAD_SIZE > getNodesABI.length) {
+            break;
+        }
+        const nodeOperatorId = Number(bytesToBigIntBE(getNodesABI.subarray(tupleBase, tupleBase + 32)) & 0xffffffffn);
+        const signerSlot = tupleBase + 3 * 32;
+        const addrBytes = getNodesABI.subarray(signerSlot, signerSlot + 20);
+        const addr = getAddress(toHex(addrBytes));
+        signers.set(addr, nodeOperatorId);
+    }
+    const info = { f, signers };
+    donInfoCache.set(key, info);
+    return info;
+}
+function computeReportHash(rawReport, reportContext) {
+    const innerHash = keccak256(toHex(rawReport));
+    return keccak256(concatHex([innerHash, toHex(reportContext)]));
+}
+function addressKeyNo0x(addr) {
+    return addr.slice(2).toLowerCase();
+}
+async function verifySigs(report, f, signers) {
+    const required = f + 1;
+    const sigs = report.sigs;
+    if (sigs.length < required) {
+        throw new WrongSignatureCountError();
+    }
+    const reportHash = computeReportHash(report.rawReport, report.reportContext);
+    const seen = new Set();
+    const accepted = [];
+    const skipErrs = [];
+    for (let i = 0; i < sigs.length; i++) {
+        if (accepted.length === required) {
+            break;
+        }
+        const attrSig = sigs[i];
+        const sigBytes = new Uint8Array(attrSig.signature);
+        if (sigBytes.length !== 65) {
+            skipErrs.push(new ParseSignatureError());
+            continue;
+        }
+        const normalized = new Uint8Array(sigBytes);
+        if (normalized[64] === 27 || normalized[64] === 28) {
+            normalized[64] -= 27;
+        }
+        let recovered;
+        try {
+            recovered = await recoverAddress({
+                hash: reportHash,
+                signature: toHex(normalized),
+            });
+        }
+        catch {
+            skipErrs.push(new RecoverSignerError());
+            continue;
+        }
+        const key = addressKeyNo0x(recovered);
+        if (seen.has(key)) {
+            skipErrs.push(new DuplicateSignerError());
+            continue;
+        }
+        seen.add(key);
+        const nodeOperatorId = signers.get(key);
+        if (nodeOperatorId === undefined) {
+            skipErrs.push(new UnknownSignerError());
+            continue;
+        }
+        attrSig.signerId = nodeOperatorId;
+        accepted.push(attrSig);
+    }
+    if (accepted.length < required) {
+        if (skipErrs.length > 0) {
+            throw new AggregateError(skipErrs);
+        }
+        throw new WrongSignatureCountError();
+    }
+    report.sigs = accepted;
+}
+function mergeReportParseConfig(overrides) {
+    return {
+        acceptedZones: overrides?.acceptedZones ?? [],
+        acceptedEnvironments: overrides !== undefined ? (overrides.acceptedEnvironments ?? []) : [productionEnvironment()],
+        skipSignatureVerification: overrides?.skipSignatureVerification ?? false,
+    };
+}
+function normalizeDonSigners(signers) {
+    const out = new Map();
+    for (const [addr, id] of signers) {
+        out.set(addr.slice(2).toLowerCase(), id);
+    }
+    return out;
+}
+export const REPORT_METADATA_HEADER_LENGTH = 109;
+const REPORT_METADATA_OFFSETS = {
+    version: 0,
+    versionSize: 1,
+    executionId: 1,
+    executionIdSize: 32,
+    timestamp: 33,
+    timestampSize: 4,
+    donId: 37,
+    donIdSize: 4,
+    donConfigVersion: 41,
+    donConfigVersionSize: 4,
+    workflowId: 45,
+    workflowIdSize: 32,
+    workflowName: 77,
+    workflowNameSize: 10,
+    workflowOwner: 87,
+    workflowOwnerSize: 20,
+    reportId: 107,
+    reportIdSize: 2,
+    bodyStart: 109,
+};
+function encodeHexLower(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i++) {
+        out += bytes[i].toString(16).padStart(2, '0');
+    }
+    return out;
+}
+function readUint32BE(raw, offset) {
+    return new DataView(raw.buffer, raw.byteOffset + offset, 4).getUint32(0, false);
+}
+function parseReportMetadataHeader(raw) {
+    if (raw === undefined || raw === null) {
+        throw new NullReportError();
+    }
+    if (raw.length < REPORT_METADATA_HEADER_LENGTH) {
+        throw new RawReportTooShortError(REPORT_METADATA_HEADER_LENGTH, raw.length);
+    }
+    const o = REPORT_METADATA_OFFSETS;
+    const workflowNameBytes = raw.subarray(o.workflowName, o.workflowName + o.workflowNameSize);
+    return {
+        version: raw[o.version],
+        executionId: encodeHexLower(raw.subarray(o.executionId, o.executionId + o.executionIdSize)),
+        timestamp: readUint32BE(raw, o.timestamp),
+        donId: readUint32BE(raw, o.donId),
+        donConfigVersion: readUint32BE(raw, o.donConfigVersion),
+        workflowId: encodeHexLower(raw.subarray(o.workflowId, o.workflowId + o.workflowIdSize)),
+        workflowName: new TextDecoder('utf-8', { fatal: false }).decode(workflowNameBytes),
+        workflowOwner: encodeHexLower(raw.subarray(o.workflowOwner, o.workflowOwner + o.workflowOwnerSize)),
+        reportId: encodeHexLower(raw.subarray(o.reportId, o.reportId + o.reportIdSize)),
+        body: raw.subarray(REPORT_METADATA_HEADER_LENGTH),
+    };
+}
 export class Report {
     report;
+    cachedHeader;
     constructor(report) {
         this.report = report.$typeName
             ? report
             : fromJson(ReportResponseSchema, report);
     }
+    static async parse(runtime, rawReport, signatures, reportContext, config) {
+        const configDigest = reportContext.length >= 32 ? reportContext.slice(0, 32) : new Uint8Array(32);
+        const seqNr = reportContext.length >= 40
+            ? new DataView(reportContext.buffer, reportContext.byteOffset + 32, 8).getBigUint64(0, false)
+            : 0n;
+        const reportResponse = create(ReportResponseSchema, {
+            configDigest,
+            seqNr,
+            reportContext,
+            rawReport,
+            sigs: signatures.map((signature) => create(AttributedSignatureSchema, { signature, signerId: 0 })),
+        });
+        const merged = mergeReportParseConfig(config);
+        const report = new Report(reportResponse);
+        if (merged.skipSignatureVerification) {
+            report.donId();
+            return report;
+        }
+        await report.verifySignaturesWithConfig(runtime, merged);
+        return report;
+    }
+    parseHeader() {
+        if (this.cachedHeader !== undefined) {
+            return this.cachedHeader;
+        }
+        this.cachedHeader = parseReportMetadataHeader(this.report.rawReport);
+        return this.cachedHeader;
+    }
+    async verifySignaturesWithConfig(runtime, config) {
+        const donId = this.donId();
+        const candidates = [];
+        for (const z of config.acceptedZones) {
+            if (z.donID === donId) {
+                candidates.push(z.environment);
+            }
+        }
+        candidates.push(...config.acceptedEnvironments);
+        if (candidates.length === 0) {
+            throw new Error(`DON ID ${donId} is not in accepted zones`);
+        }
+        const fetchFailures = [];
+        let lastVerifyErr = null;
+        for (const env of candidates) {
+            let info;
+            try {
+                info = fetchDONInfo(runtime, env, donId);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                fetchFailures.push(new Error(`could not read from chain ${env.chainSelector} contract ${env.registryAddress}: ${msg}`));
+                continue;
+            }
+            try {
+                await verifySigs(this.report, info.f, normalizeDonSigners(info.signers));
+                return;
+            }
+            catch (err) {
+                lastVerifyErr = err instanceof Error ? err : new Error(String(err));
+            }
+        }
+        if (fetchFailures.length > 0) {
+            throw new AggregateError(fetchFailures, fetchFailures.map((e) => e.message).join('\n'));
+        }
+        if (lastVerifyErr !== null) {
+            throw lastVerifyErr;
+        }
+    }
+    seqNr() {
+        return this.report.seqNr;
+    }
+    configDigest() {
+        return this.report.configDigest;
+    }
+    reportContext() {
+        return this.report.reportContext;
+    }
+    rawReport() {
+        return this.report.rawReport;
+    }
+    version() {
+        return this.parseHeader().version;
+    }
+    executionId() {
+        return this.parseHeader().executionId;
+    }
+    timestamp() {
+        return this.parseHeader().timestamp;
+    }
+    donId() {
+        return this.parseHeader().donId;
+    }
+    donConfigVersion() {
+        return this.parseHeader().donConfigVersion;
+    }
+    workflowId() {
+        return this.parseHeader().workflowId;
+    }
+    workflowName() {
+        return this.parseHeader().workflowName;
+    }
+    workflowOwner() {
+        return this.parseHeader().workflowOwner;
+    }
+    reportId() {
+        return this.parseHeader().reportId;
+    }
+    body() {
+        return this.parseHeader().body;
+    }
     // x_generatedCodeOnly_unwrap is meant to be used by the code generator only.
     x_generatedCodeOnly_unwrap() {
         return this.report;

package/dist/sdk/test/generated/capabilities/blockchain/aptos/v1alpha/aptos_mock_gen.d.ts

@@ -0,0 +1,25 @@
+import { type AccountAPTBalanceReply, type AccountAPTBalanceReplyJson, type AccountAPTBalanceRequest, type AccountTransactionsReply, type AccountTransactionsReplyJson, type AccountTransactionsRequest, type TransactionByHashReply, type TransactionByHashReplyJson, type TransactionByHashRequest, type ViewReply, type ViewReplyJson, type ViewRequest, type WriteReportReply, type WriteReportReplyJson, type WriteReportRequest } from '../../../../../../../generated/capabilities/blockchain/aptos/v1alpha/client_pb';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export declare class AptosMock {
+    static readonly CAPABILITY_ID = "aptos@1.0.0";
+    /** Set to define the return value for AccountAPTBalance. May return a plain object (AccountAPTBalanceReplyJson) or the message type. */
+    accountAPTBalance?: (input: AccountAPTBalanceRequest) => AccountAPTBalanceReply | AccountAPTBalanceReplyJson;
+    /** Set to define the return value for View. May return a plain object (ViewReplyJson) or the message type. */
+    view?: (input: ViewRequest) => ViewReply | ViewReplyJson;
+    /** Set to define the return value for TransactionByHash. May return a plain object (TransactionByHashReplyJson) or the message type. */
+    transactionByHash?: (input: TransactionByHashRequest) => TransactionByHashReply | TransactionByHashReplyJson;
+    /** Set to define the return value for AccountTransactions. May return a plain object (AccountTransactionsReplyJson) or the message type. */
+    accountTransactions?: (input: AccountTransactionsRequest) => AccountTransactionsReply | AccountTransactionsReplyJson;
+    /** Set to define the return value for WriteReport. May return a plain object (WriteReportReplyJson) or the message type. */
+    writeReport?: (input: WriteReportRequest) => WriteReportReply | WriteReportReplyJson;
+    private constructor();
+    /**
+     * Returns the mock instance for this capability and the specified tags.
+     * Multiple calls with the same tag values return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance(chainSelector: bigint): AptosMock;
+}

package/dist/sdk/test/generated/capabilities/blockchain/aptos/v1alpha/aptos_mock_gen.js

@@ -0,0 +1,111 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { AccountAPTBalanceReplySchema, AccountAPTBalanceRequestSchema, AccountTransactionsReplySchema, AccountTransactionsRequestSchema, TransactionByHashReplySchema, TransactionByHashRequestSchema, ViewReplySchema, ViewRequestSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../../../generated/capabilities/blockchain/aptos/v1alpha/client_pb';
+import { __getTestMockInstance, __setTestMockInstance, registerTestCapability, } from '../../../../../../testutils/test-runtime';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export class AptosMock {
+    static CAPABILITY_ID = 'aptos@1.0.0';
+    /** Set to define the return value for AccountAPTBalance. May return a plain object (AccountAPTBalanceReplyJson) or the message type. */
+    accountAPTBalance;
+    /** Set to define the return value for View. May return a plain object (ViewReplyJson) or the message type. */
+    view;
+    /** Set to define the return value for TransactionByHash. May return a plain object (TransactionByHashReplyJson) or the message type. */
+    transactionByHash;
+    /** Set to define the return value for AccountTransactions. May return a plain object (AccountTransactionsReplyJson) or the message type. */
+    accountTransactions;
+    /** Set to define the return value for WriteReport. May return a plain object (WriteReportReplyJson) or the message type. */
+    writeReport;
+    constructor(chainSelector) {
+        const self = this;
+        const qualifiedId = `aptos:ChainSelector:${chainSelector}@1.0.0`;
+        try {
+            registerTestCapability(qualifiedId, (req) => {
+                switch (req.method) {
+                    case 'AccountAPTBalance': {
+                        const input = anyUnpack(req.payload, AccountAPTBalanceRequestSchema);
+                        const handler = self.accountAPTBalance;
+                        if (typeof handler !== 'function')
+                            throw new Error("AccountAPTBalance: no implementation provided; set the mock's accountAPTBalance property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(AccountAPTBalanceReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(AccountAPTBalanceReplySchema, output) },
+                        };
+                    }
+                    case 'View': {
+                        const input = anyUnpack(req.payload, ViewRequestSchema);
+                        const handler = self.view;
+                        if (typeof handler !== 'function')
+                            throw new Error("View: no implementation provided; set the mock's view property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(ViewReplySchema, raw);
+                        return { response: { case: 'payload', value: anyPack(ViewReplySchema, output) } };
+                    }
+                    case 'TransactionByHash': {
+                        const input = anyUnpack(req.payload, TransactionByHashRequestSchema);
+                        const handler = self.transactionByHash;
+                        if (typeof handler !== 'function')
+                            throw new Error("TransactionByHash: no implementation provided; set the mock's transactionByHash property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(TransactionByHashReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(TransactionByHashReplySchema, output) },
+                        };
+                    }
+                    case 'AccountTransactions': {
+                        const input = anyUnpack(req.payload, AccountTransactionsRequestSchema);
+                        const handler = self.accountTransactions;
+                        if (typeof handler !== 'function')
+                            throw new Error("AccountTransactions: no implementation provided; set the mock's accountTransactions property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(AccountTransactionsReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(AccountTransactionsReplySchema, output) },
+                        };
+                    }
+                    case 'WriteReport': {
+                        const input = anyUnpack(req.payload, WriteReportRequestSchema);
+                        const handler = self.writeReport;
+                        if (typeof handler !== 'function')
+                            throw new Error("WriteReport: no implementation provided; set the mock's writeReport property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(WriteReportReplySchema, raw);
+                        return { response: { case: 'payload', value: anyPack(WriteReportReplySchema, output) } };
+                    }
+                    default:
+                        return { response: { case: 'error', value: `unknown method ${req.method}` } };
+                }
+            });
+        }
+        catch {
+            throw new Error("Capability mocks must be used within the CRE test framework's test() method.");
+        }
+    }
+    /**
+     * Returns the mock instance for this capability and the specified tags.
+     * Multiple calls with the same tag values return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance(chainSelector) {
+        const qualifiedId = `aptos:ChainSelector:${chainSelector}@1.0.0`;
+        let instance = __getTestMockInstance(qualifiedId);
+        if (!instance) {
+            instance = new AptosMock(chainSelector);
+            __setTestMockInstance(qualifiedId, instance);
+        }
+        return instance;
+    }
+}

package/dist/sdk/test/generated/capabilities/blockchain/solana/v1alpha/solana_mock_gen.d.ts

@@ -0,0 +1,33 @@
+import { type GetAccountInfoWithOptsReply, type GetAccountInfoWithOptsReplyJson, type GetAccountInfoWithOptsRequest, type GetBalanceReply, type GetBalanceReplyJson, type GetBalanceRequest, type GetBlockReply, type GetBlockReplyJson, type GetBlockRequest, type GetFeeForMessageReply, type GetFeeForMessageReplyJson, type GetFeeForMessageRequest, type GetMultipleAccountsWithOptsReply, type GetMultipleAccountsWithOptsReplyJson, type GetMultipleAccountsWithOptsRequest, type GetSignatureStatusesReply, type GetSignatureStatusesReplyJson, type GetSignatureStatusesRequest, type GetSlotHeightReply, type GetSlotHeightReplyJson, type GetSlotHeightRequest, type GetTransactionReply, type GetTransactionReplyJson, type GetTransactionRequest, type WriteReportReply, type WriteReportReplyJson, type WriteReportRequest } from '../../../../../../../generated/capabilities/blockchain/solana/v1alpha/client_pb';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export declare class SolanaMock {
+    static readonly CAPABILITY_ID = "solana@1.0.0";
+    /** Set to define the return value for GetAccountInfoWithOpts. May return a plain object (GetAccountInfoWithOptsReplyJson) or the message type. */
+    getAccountInfoWithOpts?: (input: GetAccountInfoWithOptsRequest) => GetAccountInfoWithOptsReply | GetAccountInfoWithOptsReplyJson;
+    /** Set to define the return value for GetBalance. May return a plain object (GetBalanceReplyJson) or the message type. */
+    getBalance?: (input: GetBalanceRequest) => GetBalanceReply | GetBalanceReplyJson;
+    /** Set to define the return value for GetBlock. May return a plain object (GetBlockReplyJson) or the message type. */
+    getBlock?: (input: GetBlockRequest) => GetBlockReply | GetBlockReplyJson;
+    /** Set to define the return value for GetFeeForMessage. May return a plain object (GetFeeForMessageReplyJson) or the message type. */
+    getFeeForMessage?: (input: GetFeeForMessageRequest) => GetFeeForMessageReply | GetFeeForMessageReplyJson;
+    /** Set to define the return value for GetMultipleAccountsWithOpts. May return a plain object (GetMultipleAccountsWithOptsReplyJson) or the message type. */
+    getMultipleAccountsWithOpts?: (input: GetMultipleAccountsWithOptsRequest) => GetMultipleAccountsWithOptsReply | GetMultipleAccountsWithOptsReplyJson;
+    /** Set to define the return value for GetSignatureStatuses. May return a plain object (GetSignatureStatusesReplyJson) or the message type. */
+    getSignatureStatuses?: (input: GetSignatureStatusesRequest) => GetSignatureStatusesReply | GetSignatureStatusesReplyJson;
+    /** Set to define the return value for GetSlotHeight. May return a plain object (GetSlotHeightReplyJson) or the message type. */
+    getSlotHeight?: (input: GetSlotHeightRequest) => GetSlotHeightReply | GetSlotHeightReplyJson;
+    /** Set to define the return value for GetTransaction. May return a plain object (GetTransactionReplyJson) or the message type. */
+    getTransaction?: (input: GetTransactionRequest) => GetTransactionReply | GetTransactionReplyJson;
+    /** Set to define the return value for WriteReport. May return a plain object (WriteReportReplyJson) or the message type. */
+    writeReport?: (input: WriteReportRequest) => WriteReportReply | WriteReportReplyJson;
+    private constructor();
+    /**
+     * Returns the mock instance for this capability and the specified tags.
+     * Multiple calls with the same tag values return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance(chainSelector: bigint): SolanaMock;
+}