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

package/LICENSE.md

@@ -1,9 +1,9 @@
-Business Source License 1.1
+Business Source License 1.1 (BUSL-1.1)
 
 License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
 "Business Source License" is a trademark of MariaDB Corporation Ab.
 
------------------------------------------------------------------------------
+---
 
 Parameters
 
@@ -17,7 +17,7 @@ Change Date: May 20, 2029
 
 Change License: MIT
 
------------------------------------------------------------------------------
+---
 
 Terms
 
@@ -37,13 +37,13 @@ This License does not grant you any right in any trademark or logo of Licensor o
 
 TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.
 
-MariaDB hereby grants you permission to use this License’s text to license your works, and to refer to it using the trademark "Business Source License", as long as you comply with the Covenants of Licensor below.
+MariaDB hereby grants you permission to use this License's text to license your works, and to refer to it using the trademark "Business Source License", as long as you comply with the Covenants of Licensor below.
 
------------------------------------------------------------------------------
+---
 
 Covenants of Licensor
 
-In consideration of the right to use this License’s text and the "Business Source License" name and trademark, Licensor covenants to MariaDB, and to all other recipients of the licensed work to be provided by Licensor:
+In consideration of the right to use this License's text and the "Business Source License" name and trademark, Licensor covenants to MariaDB, and to all other recipients of the licensed work to be provided by Licensor:
 
 1. To specify as the Change License the GPL Version 2.0 or any later version, or a license that is compatible with GPL Version 2.0 or a later version, where "compatible" means that software provided under the Change License can be included in a program with software provided under GPL Version 2.0 or a later version. Licensor may specify additional Change Licenses without limitation.
 
@@ -51,4 +51,4 @@ In consideration of the right to use this License’s text and the "Business Sou
 
 3. To specify a Change Date.
 
-4. Not to modify this License in any other way.
+4. Not to modify this License in any other way.

package/README.md

@@ -1,40 +1,83 @@
 # @chainlink/cre-sdk
 
-The Chainlink Runtime Environment (CRE) SDK for TypeScript enables developers to build decentralized workflows that combine off-chain computation with on-chain execution. Create workflows that fetch data from APIs, interact with smart contracts, and coordinate complex multi-step operations across blockchain networks.
+The Chainlink Runtime Environment (CRE) SDK for TypeScript enables developers to write decentralized [Chainlink Runtime Environment Workflows](https://docs.chain.link/cre/) in Typescript.
+
+## Table of Contents
+
+- [How to use this SDK](#how-to-use-this-sdk)
+- [Examples](#examples)
+- [Simulate locally with CRE CLI](#simulate-locally-with-cre-cli)
+- [Installation](#installation)
+- [Core Concepts](#core-concepts)
+  - [Workflows](#workflows)
+  - [Runtime Modes](#runtime-modes)
+- [Available Capabilities](#available-capabilities)
+  - [Scheduling](#scheduling)
+  - [HTTP Operations](#http-operations)
+  - [Blockchain Interactions](#blockchain-interactions)
+- [Configuration & Type Safety](#configuration--type-safety)
+- [Consensus & Aggregation](#consensus--aggregation)
+- [Utility Functions](#utility-functions)
+  - [Hex Utilities](#hex-utilities)
+  - [Chain Selectors](#chain-selectors)
+- [Example Workflows](#example-workflows)
+  - [1. Simple Scheduled Task](#1-simple-scheduled-task)
+  - [2. API Data Aggregation](#2-api-data-aggregation)
+  - [3. On-Chain Data Integration](#3-on-chain-data-integration)
+- [API Reference](#api-reference)
+  - [Core Functions](#core-functions)
+  - [Capabilities](#capabilities)
+  - [Utilities](#utilities)
+- [Building from Source](#building-from-source)
+  - [Protobuf Generation](#protobuf-generation)
+  - [Chain Selectors Generation](#chain-selectors-generation)
+- [Requirements](#requirements)
+- [License](#license)
+
+## How to use this SDK
+
+This package exposes the APIs you use to write CRE Workflows in TypeScript, and then compile them to WASM.
+
+This package must be used along with the [CRE CLI tool](https://github.com/smartcontractkit/cre-cli) to deploy your WASM-compiled workflows.
+
+## Prerequisites
+
+1. the [bun runtime](https://bun.com/). The wasm compilation currently is only supported by the bun runtime which has near-complete NodeJS compatibility.
+
+2. the [CRE CLI tool](https://github.com/smartcontractkit/cre-cli) installed.
+
+## Getting Started
+
+We recommend you consult the [getting started docs](https://docs.chain.link/cre/getting-started/cli-installation) and install the CRE CLI.
+
+Then run `cre init`, name your project and choose TypeScript as the language to define your workflows in.
 
 ## Examples
 
-Ready to clone repo with example workflows and cre-sdk set up: [cre-sdk-examples](https://github.com/smartcontractkit/cre-sdk-typescript/tree/main/packages/cre-sdk-examples).
+This TypeScript CRE SDK also includes some reference examples - [cre-sdk-examples](https://github.com/smartcontractkit/cre-sdk-typescript/tree/main/packages/cre-sdk-examples). These can be copied and pasted into your project as needed.
 
-## Installation
+⚠️ Note however that these are refence TypeScript workflows and may require some additional steps (having the CRE CLI installed, running `bunx cre-setup` from inside a workflow example directory, etc) to get them to work within this repo.
 
-```bash
-bun add @chainlink/cre-sdk
-```
+**We recommend you setup your project using the CRE CLI and then copy and paste these examples into your project**
 
-## Quick Start
+## Simulate locally with CRE CLI
 
-```typescript
-import { cre, Value, withErrorBoundary } from "@chainlink/cre-sdk";
+You can run and debug your TypeScript workflows locally using [the CRE CLI's](https://github.com/smartcontractkit/cre-cli) simulation functionality.
 
-const onCronTrigger = async (config: { schedule: string }) => {
-  // Your workflow logic here
-  cre.sendResponseValue(Value.from("Hello, CRE!"));
-};
+Make sure you `cd` into the directory that contain's your workflow's TypeScript file and the associated `config.json`. Then:
 
-const initWorkflow = (config: { schedule: string }) => {
-  const cron = new cre.capabilities.CronCapability();
-  return [
-    cre.handler(cron.trigger({ schedule: config.schedule }), onCronTrigger),
-  ];
-};
+```bash
+cre workflow simulate --target local-simulation --config config.json index.ts
+```
 
-export async function main() {
-  const runner = await cre.newRunner<{ schedule: string }>();
-  await runner.run(initWorkflow);
-}
+When simulating workflows that write to the blockchain, remember to pass extra flag `--broadcast` to broadcast the transactions to the blockchain.
+
+See the CLI docs for additional flags (e.g. config file, secrets, HTTP payloads, EVM log params).
+
+## Installation
 
-withErrorBoundary(main);
+```bash
+bun add @chainlink/cre-sdk
 ```
 
 ## Core Concepts
@@ -44,7 +87,7 @@ withErrorBoundary(main);
 Workflows are the fundamental building blocks of CRE applications. They define how your application responds to triggers and what actions to take. Each workflow consists of:
 
 - **Triggers**: Events that initiate workflow execution (cron schedules, HTTP requests, etc.)
-- **Handlers**: Functions that process trigger events and execute your business logic
+- **Handlers**: Functions that process trigger events and execute your business logic as provided in a callback function.
 - **Capabilities**: Built-in services for interacting with external systems
 
 ### Runtime Modes
@@ -54,15 +97,9 @@ CRE supports two execution modes:
 - **DON Mode**: Distributed execution across multiple nodes for consensus and reliability
 - **Node Mode**: Individual node execution for specific tasks requiring node-level operations
 
-Use `cre.runInNodeMode()` to execute functions that require individual node processing, such as fetching data from different sources for consensus aggregation.
-
-### Error Handling
+Use `runtime.runInNodeMode()` to execute functions that require individual node processing, such as fetching data from different sources for consensus aggregation.
 
-Always wrap your main function with `withErrorBoundary()` to ensure proper error handling and workflow termination:
-
-```typescript
-withErrorBoundary(main);
-```
+The SDK wires runtime safety internally; you can call `main()` directly as shown in the examples.
 
 ## Available Capabilities
 
@@ -82,18 +119,30 @@ const trigger = cron.trigger({ schedule: "0 */5 * * * *" }); // Every 5 minutes
 Fetch data from external APIs with built-in consensus mechanisms:
 
 ```typescript
-import { cre, consensusMedianAggregation } from "@chainlink/cre-sdk";
+import {
+  cre,
+  consensusMedianAggregation,
+  type HTTPSendRequester,
+  type Runtime,
+} from "@chainlink/cre-sdk";
 
-const fetchData = async (config: { apiUrl: string }) => {
-  const response = await cre.utils.fetch({ url: config.apiUrl });
-  return Number.parseFloat(response.body.trim());
+type Config = { apiUrl: string };
+
+const fetchData = (sendRequester: HTTPSendRequester, config: Config) => {
+  const response = sendRequester.sendRequest({ url: config.apiUrl }).result();
+  return Number.parseFloat(Buffer.from(response.body).toString("utf-8").trim());
 };
 
-// Execute with consensus across multiple nodes
-const result = await cre.runInNodeMode(
-  fetchData,
-  consensusMedianAggregation()
-)(config);
+const onCronTrigger = (runtime: Runtime<Config>) => {
+  const httpCapability = new cre.capabilities.HTTPClient();
+  return httpCapability
+    .sendRequest(
+      runtime,
+      fetchData,
+      consensusMedianAggregation()
+    )(runtime.config)
+    .result();
+};
 ```
 
 ### Blockchain Interactions
@@ -101,45 +150,75 @@ const result = await cre.runInNodeMode(
 Read from and write to EVM-compatible blockchains:
 
 ```typescript
-import { cre, hexToBase64 } from "@chainlink/cre-sdk";
-import { encodeFunctionData, decodeFunctionResult } from "viem";
-
-// Initialize EVM client with chain selector
-const evmClient = new cre.capabilities.EVMClient(
-  undefined, // default mode
-  BigInt("5009297550715157269") // Ethereum Sepolia
-);
-
-// Read from contract
-const callData = encodeFunctionData({
-  abi: CONTRACT_ABI,
-  functionName: "getValue",
-});
+import {
+  bytesToHex,
+  cre,
+  getNetwork,
+  hexToBase64,
+  type Runtime,
+} from "@chainlink/cre-sdk";
+import { decodeFunctionResult, encodeFunctionData, zeroAddress } from "viem";
 
-const result = await evmClient.callContract({
-  call: {
-    from: hexToBase64("0x0000000000000000000000000000000000000000"),
-    to: hexToBase64(contractAddress),
-    data: hexToBase64(callData),
-  },
-  blockNumber: {
-    absVal: Buffer.from([3]).toString("base64"), // finalized block
-    sign: "-1",
-  },
-});
+type Config = { evm: { chainSelectorName: string; contractAddress: string } };
 
-// Write to contract
-await evmClient.writeReport({
-  receiver: contractAddress,
-  report: {
-    rawReport: callData,
-  },
-});
+const onCronTrigger = async (runtime: Runtime<Config>) => {
+  const { chainSelectorName, contractAddress } = runtime.config.evm;
+  const network = getNetwork({
+    chainFamily: "evm",
+    chainSelectorName,
+    isTestnet: true,
+  });
+  if (!network) throw new Error("Network not found");
+
+  const evmClient = new cre.capabilities.EVMClient(
+    network.chainSelector.selector
+  );
+
+  const callData = encodeFunctionData({
+    abi: CONTRACT_ABI,
+    functionName: "getValue",
+  });
+
+  const contractCall = evmClient
+    .callContract(runtime, {
+      call: {
+        from: hexToBase64(zeroAddress),
+        to: hexToBase64(contractAddress),
+        data: hexToBase64(callData),
+      },
+      blockNumber: { absVal: Buffer.from([3]).toString("base64"), sign: "-1" },
+    })
+    .result();
+
+  const onchainValue = decodeFunctionResult({
+    abi: CONTRACT_ABI,
+    functionName: "getValue",
+    data: bytesToHex(contractCall.data),
+  });
+
+  // Write example
+  const writeData = encodeFunctionData({
+    abi: CONTRACT_ABI,
+    functionName: "setValue",
+    args: [onchainValue],
+  });
+  const tx = evmClient
+    .writeReport(runtime, {
+      receiver: contractAddress,
+      report: { rawReport: writeData },
+    })
+    .result();
+  return { onchainValue, txHash: tx.txHash?.toString() };
+};
 ```
 
 ## Configuration & Type Safety
 
-Use Zod schemas for type-safe configuration:
+You, the developer, must declare config files in config.json files, co-located with your TypeScript workflow definition.
+
+Use Zod schemas for type-safe configuration.
+
+Here's an example of zod usage for the config specified in `../cre-sdk-examples/src/workflows/on-chain/config.json`
 
 ```typescript
 import { z } from "zod";
@@ -149,7 +228,7 @@ const configSchema = z.object({
   apiUrl: z.string(),
   evms: z.array(
     z.object({
-      chainSelector: z.string(),
+      chainSelectorName: z.string(),
       contractAddress: z.string(),
     })
   ),
@@ -158,7 +237,7 @@ const configSchema = z.object({
 type Config = z.infer<typeof configSchema>;
 
 export async function main() {
-  const runner = await cre.newRunner<Config>({ configSchema });
+  const runner = await Runner.newRunner<Config>({ configSchema });
   await runner.run(initWorkflow);
 }
 ```
@@ -168,38 +247,36 @@ export async function main() {
 CRE provides built-in consensus mechanisms for aggregating data from multiple nodes:
 
 ```typescript
-import { consensusMedianAggregation } from "@chainlink/cre-sdk";
+import {
+  consensusMedianAggregation,
+  type NodeRuntime,
+  type Runtime,
+} from "@chainlink/cre-sdk";
+
+const fetchDataFunction = async (nodeRuntime: NodeRuntime<Config>) => 42;
 
 // Execute function across multiple nodes and aggregate results
-const aggregatedValue = await cre.runInNodeMode(
+const aggregatedValue = await runtime.runInNodeMode(
   fetchDataFunction,
   consensusMedianAggregation()
-)(config);
+)();
 ```
 
 ## Utility Functions
 
-### Value Serialization
+### Hex Utilities
 
-```typescript
-import { Value } from "@chainlink/cre-sdk";
-
-// Send structured response data
-cre.sendResponseValue(
-  Value.from({
-    price: 1234.56,
-    timestamp: Date.now(),
-    source: "api.example.com",
-  })
-);
-```
+CRE capabilities (like EVM client) expect data in base64 format for serialization. You may need to convert a hex string to base64 format for CRE protocol communication.
 
-### Hex Utilities
+Or you may need to convert binary data back to hex format for blockchain operations. This can be Useful for decoding responses from CRE capabilities and transforming data for libraries like viem (which expect hex format)
 
 ```typescript
 import { hexToBase64, bytesToHex } from "@chainlink/cre-sdk";
 
+// Example: "0x1234567890abcdef" → "EjRWeJCrze8="
 const base64Data = hexToBase64("0x1234567890abcdef");
+
+// Example: Uint8Array([18, 52, 86...]) → "0x1234567890abcdef"
 const hexData = bytesToHex(buffer);
 ```
 
@@ -208,217 +285,47 @@ const hexData = bytesToHex(buffer);
 ```typescript
 import { getAllNetworks, getNetwork } from "@chainlink/cre-sdk";
 
-const networks = getAllNetworks();
-const ethereum = getNetwork("ethereum-mainnet");
+const allNetworks = getAllNetworks();
+const ethereumSepolia = getNetwork({
+  chainFamily: "evm",
+  chainSelectorName: "ethereum-sepolia",
+  isTestnet: true,
+});
 ```
 
 ## Example Workflows
 
-### 1. Simple Scheduled Task
-
-```typescript
-import { cre, Value, withErrorBoundary } from "@chainlink/cre-sdk";
-
-const onCronTrigger = () => {
-  console.log("Workflow executed!");
-  cre.sendResponseValue(Value.from("Task completed"));
-};
-
-const initWorkflow = (config: { schedule: string }) => {
-  const cron = new cre.capabilities.CronCapability();
-  return [
-    cre.handler(cron.trigger({ schedule: config.schedule }), onCronTrigger),
-  ];
-};
+### 1. Simple Cron-scheduled task
 
-export async function main() {
-  const runner = await cre.newRunner<{ schedule: string }>();
-  await runner.run(initWorkflow);
-}
-
-withErrorBoundary(main);
-```
+See the [hello-world](https://github.com/smartcontractkit/cre-sdk-typescript/tree/main/packages/cre-sdk-examples/src/hello-world) example for a simple example that runs a cron-based operation on CRE at intervals you define in the `config.js` file.
 
 ### 2. API Data Aggregation
 
-```typescript
-import {
-  cre,
-  consensusMedianAggregation,
-  Value,
-  withErrorBoundary,
-} from "@chainlink/cre-sdk";
-import { z } from "zod";
-
-const configSchema = z.object({
-  schedule: z.string(),
-  apiUrl: z.string(),
-});
-
-type Config = z.infer<typeof configSchema>;
-
-const fetchPrice = async (config: Config) => {
-  const response = await cre.utils.fetch({ url: config.apiUrl });
-  return Number.parseFloat(response.body.trim());
-};
-
-const onCronTrigger = async (config: Config) => {
-  const price = await cre.runInNodeMode(
-    fetchPrice,
-    consensusMedianAggregation()
-  )(config);
-
-  cre.sendResponseValue(Value.from({ price }));
-};
-
-const initWorkflow = (config: Config) => {
-  const cron = new cre.capabilities.CronCapability();
-  return [
-    cre.handler(cron.trigger({ schedule: config.schedule }), onCronTrigger),
-  ];
-};
-
-export async function main() {
-  const runner = await cre.newRunner<Config>({ configSchema });
-  await runner.run(initWorkflow);
-}
-
-withErrorBoundary(main);
-```
+See the [http-fetch example](https://github.com/smartcontractkit/cre-sdk-typescript/tree/main/packages/cre-sdk-examples/src/workflows/http-fetch) for a complete implementation that fetches data from external APIs, with Chainlink CRE consensus aggregation applied.
 
 ### 3. On-Chain Data Integration
 
-```typescript
-import {
-  cre,
-  consensusMedianAggregation,
-  Value,
-  withErrorBoundary,
-  hexToBase64,
-  bytesToHex,
-} from "@chainlink/cre-sdk";
-import { encodeFunctionData, decodeFunctionResult, zeroAddress } from "viem";
-import { z } from "zod";
-
-const configSchema = z.object({
-  schedule: z.string(),
-  apiUrl: z.string(),
-  evms: z.array(
-    z.object({
-      chainSelector: z.string(),
-      contractAddress: z.string(),
-    })
-  ),
-});
-
-type Config = z.infer<typeof configSchema>;
-
-const fetchOffchainData = async (config: Config) => {
-  const response = await cre.utils.fetch({ url: config.apiUrl });
-  return Number.parseFloat(response.body.trim());
-};
-
-const onCronTrigger = async (config: Config) => {
-  // Get off-chain data with consensus
-  const offchainValue = await cre.runInNodeMode(
-    fetchOffchainData,
-    consensusMedianAggregation()
-  )(config);
-
-  // Read on-chain data
-  const evmConfig = config.evms[0];
-  const evmClient = new cre.capabilities.EVMClient(
-    undefined,
-    BigInt(evmConfig.chainSelector)
-  );
-
-  const callData = encodeFunctionData({
-    abi: [
-      {
-        name: "getValue",
-        type: "function",
-        inputs: [],
-        outputs: [{ type: "uint256" }],
-      },
-    ],
-    functionName: "getValue",
-  });
-
-  const contractCall = await evmClient.callContract({
-    call: {
-      from: hexToBase64(zeroAddress),
-      to: hexToBase64(evmConfig.contractAddress),
-      data: hexToBase64(callData),
-    },
-    blockNumber: {
-      absVal: Buffer.from([3]).toString("base64"),
-      sign: "-1",
-    },
-  });
-
-  const onchainValue = decodeFunctionResult({
-    abi: [
-      {
-        name: "getValue",
-        type: "function",
-        inputs: [],
-        outputs: [{ type: "uint256" }],
-      },
-    ],
-    functionName: "getValue",
-    data: bytesToHex(contractCall.data),
-  });
-
-  // Combine and return results
-  const finalResult = Number(onchainValue) + offchainValue;
-
-  cre.sendResponseValue(
-    Value.from({
-      offchainValue,
-      onchainValue: Number(onchainValue),
-      finalResult,
-    })
-  );
-};
-
-const initWorkflow = (config: Config) => {
-  const cron = new cre.capabilities.CronCapability();
-  return [
-    cre.handler(cron.trigger({ schedule: config.schedule }), onCronTrigger),
-  ];
-};
-
-export async function main() {
-  const runner = await cre.newRunner<Config>({ configSchema });
-  await runner.run(initWorkflow);
-}
-
-withErrorBoundary(main);
-```
+See the [on-chain example](https://github.com/smartcontractkit/cre-sdk-typescript/tree/main/packages/cre-sdk-examples/src/workflows/on-chain) for reading from smart contracts, and the [on-chain-write example](https://github.com/smartcontractkit/cre-sdk-typescript/tree/main/packages/cre-sdk-examples/src/workflows/on-chain-write) for writing to smart contracts.
 
 ## API Reference
 
 ### Core Functions
 
-- `cre.newRunner<T>(options?)`: Create a new workflow runner
+- `Runner.newRunner<T>(options?)`: Create a new workflow runner
 - `cre.handler(trigger, handler)`: Create a trigger-handler pair
-- `cre.sendResponseValue(value)`: Send workflow response
-- `cre.runInNodeMode(fn, aggregator)`: Execute function in node mode with consensus
-- `withErrorBoundary(fn)`: Wrap function with error handling
+- `runtime.runInNodeMode(fn, aggregator)`: Execute function in node mode with consensus
 
 ### Capabilities
 
 - `cre.capabilities.CronCapability`: Schedule-based triggers
-- `cre.capabilities.HTTPCapability`: HTTP request handling
-- `cre.capabilities.HTTPClient`: HTTP client for requests
+- `cre.capabilities.HTTPClient`: HTTP client for requests with consensus support
 - `cre.capabilities.EVMClient`: EVM blockchain interactions
 
 ### Utilities
 
-- `cre.utils.fetch()`: HTTP requests with consensus support
-- `Value.from()`: Serialize response values
 - `consensusMedianAggregation()`: Median consensus aggregator
 - `hexToBase64()`, `bytesToHex()`: Data format conversions
+- `getAllNetworks()`, `getNetwork(...)`: Chain selector metadata
 
 ## Building from Source
 
@@ -428,6 +335,9 @@ To build the SDK locally:
 # Install dependencies (from monorepo root)
 bun install
 
+# Make sure Chainlink CRE Javy Plugin is ready
+bun cre-setup
+
 # Generate protocol buffers and SDK types
 bun generate:sdk
 
@@ -443,11 +353,11 @@ bun test:standard
 
 ### Protobuf Generation
 
-This SDK uses [ts-proto](https://github.com/stephenh/ts-proto) for generating TypeScript types from Protocol Buffers.
+This SDK uses [@bufbuild/protobuf](https://www.npmjs.com/package/@bufbuild/protobuf) for generating TypeScript types from Protocol Buffers.
 
 **Available Commands:**
 
-- `bun generate:proto` - Generate TypeScript types from .proto files
+- `bun generate:sdk` - Generate TypeScript types from .proto files as well as custom tailored utility classes
 - `bun proto:lint` - Lint .proto files
 - `bun proto:format` - Format .proto files
 
@@ -472,7 +382,11 @@ bun generate:chain-selectors
 ```typescript
 import { getAllNetworks, getNetwork } from "@chainlink/cre-sdk";
 
-const ethereum = getNetwork("ethereum-mainnet");
+const ethereum = getNetwork({
+  chainFamily: "evm",
+  chainSelectorName: "ethereum-mainnet",
+  isTestnet: false,
+});
 const allNetworks = getAllNetworks();
 ```
 

package/dist/generated/chain-selectors/mainnet/aptos/aptos-mainnet.js

@@ -4,7 +4,7 @@ const network = {
     chainId: '1',
     chainSelector: {
         name: 'aptos-mainnet',
-        selector: '4741433654826278000',
+        selector: 4741433654826277614n,
     },
     chainFamily: 'aptos',
     networkType: 'mainnet',

package/dist/generated/chain-selectors/mainnet/evm/0g-mainnet.js

@@ -4,7 +4,7 @@ const network = {
     chainId: '16661',
     chainSelector: {
         name: '0g-mainnet',
-        selector: '4426351306075016000',
+        selector: 4426351306075016396n,
     },
     chainFamily: 'evm',
     networkType: 'mainnet',