@ckb-ccc/core 1.22.0 → 1.23.0

package/src/codec/codec.ts

@@ -2,20 +2,17 @@
 
 import { Bytes, bytesFrom, BytesLike } from "../bytes/index.js";
 
-export type CodecLike<Encodable, Decoded = Encodable> = {
+export type CodecLike<Encodable, Decoded = Encodable, Context = any> = {
   readonly encode: (encodable: Encodable) => Bytes;
-  readonly decode: (
-    decodable: BytesLike,
-    config?: { isExtraFieldIgnored?: boolean },
-  ) => Decoded;
+  readonly decode: (decodable: BytesLike, context?: Context) => Decoded;
   readonly byteLength?: number;
 };
-export class Codec<Encodable, Decoded = Encodable> {
+export class Codec<Encodable, Decoded = Encodable, Context = any> {
   constructor(
     public readonly encode: (encodable: Encodable) => Bytes,
     public readonly decode: (
       decodable: BytesLike,
-      config?: { isExtraFieldIgnored?: boolean }, // This is equivalent to "compatible" in the Rust implementation of Molecule.
+      context?: Context,
     ) => Decoded,
     public readonly byteLength?: number, // if provided, treat codec as fixed length
   ) {}
@@ -28,23 +25,23 @@ export class Codec<Encodable, Decoded = Encodable> {
     }
   }
 
-  decodeOr<T>(
-    decodable: BytesLike,
-    fallback: T,
-    config?: { isExtraFieldIgnored?: boolean }, // This is equivalent to "compatible" in the Rust implementation of Molecule.
-  ) {
+  decodeOr<T>(decodable: BytesLike, fallback: T, context?: Context) {
     try {
-      return this.decode(decodable, config);
+      return this.decode(decodable, context);
     } catch (_) {
       return fallback;
     }
   }
 
-  static from<Encodable, Decoded = Encodable>({
+  static from<Encodable, Decoded = Encodable, Context = any>({
     encode,
     decode,
     byteLength,
-  }: CodecLike<Encodable, Decoded>): Codec<Encodable, Decoded> {
+  }: CodecLike<Encodable, Decoded, Context>): Codec<
+    Encodable,
+    Decoded,
+    Context
+  > {
     return new Codec(
       (encodable: Encodable) => {
         const encoded = encode(encodable);
@@ -55,7 +52,7 @@ export class Codec<Encodable, Decoded = Encodable> {
         }
         return encoded;
       },
-      (decodable, config) => {
+      (decodable, context) => {
         const decodableBytes = bytesFrom(decodable);
         if (
           byteLength !== undefined &&
@@ -65,7 +62,7 @@ export class Codec<Encodable, Decoded = Encodable> {
             `Codec.decode: expected byte length ${byteLength}, got ${decodableBytes.byteLength}`,
           );
         }
-        return decode(decodable, config);
+        return decode(decodable, context);
       },
       byteLength,
     );
@@ -77,32 +74,59 @@ export class Codec<Encodable, Decoded = Encodable> {
   }: {
     inMap?: (encodable: NewEncodable) => Encodable;
     outMap?: (decoded: Decoded) => NewDecoded;
-  }): Codec<NewEncodable, NewDecoded> {
+  }): Codec<NewEncodable, NewDecoded, Context> {
     return new Codec(
       (encodable) =>
         this.encode((inMap ? inMap(encodable) : encodable) as Encodable),
-      (buffer, config) =>
+      (buffer, context) =>
         (outMap
-          ? outMap(this.decode(buffer, config))
-          : this.decode(buffer, config)) as NewDecoded,
+          ? outMap(this.decode(buffer, context))
+          : this.decode(buffer, context)) as NewDecoded,
       this.byteLength,
     );
   }
 
   mapIn<NewEncodable>(
     map: (encodable: NewEncodable) => Encodable,
-  ): Codec<NewEncodable, Decoded> {
+  ): Codec<NewEncodable, Decoded, Context> {
     return this.map({ inMap: map });
   }
 
   mapOut<NewDecoded>(
     map: (decoded: Decoded) => NewDecoded,
-  ): Codec<Encodable, NewDecoded> {
+  ): Codec<Encodable, NewDecoded, Context> {
     return this.map({ outMap: map });
   }
 }
 
-export type EncodableType<T extends CodecLike<any, any>> =
-  T extends CodecLike<infer Encodable, unknown> ? Encodable : never;
-export type DecodedType<T extends CodecLike<any, any>> =
-  T extends CodecLike<any, infer Decoded> ? Decoded : never;
+export type EncodableType<T extends CodecLike<any, any, any>> =
+  T extends CodecLike<infer Encodable, unknown, any> ? Encodable : never;
+export type DecodedType<T extends CodecLike<any, any, any>> =
+  T extends CodecLike<any, infer Decoded, any> ? Decoded : never;
+
+type IsAny<T> = 0 extends 1 & T ? true : false;
+
+/**
+ * The context a codec specifically requires when composed with other codecs.
+ * Legacy `any` is normalized to `unknown`, while `Extract` preserves that the
+ * normalized type is assignable to the codec's original context.
+ */
+export type ContextType<T extends CodecLike<any, any, any>> = T extends {
+  readonly decode: (decodable: BytesLike, context?: infer Context) => unknown;
+}
+  ? Extract<IsAny<Context> extends true ? unknown : Context, Context>
+  : unknown;
+
+/**
+ * The combined context required by every codec in a record.
+ *
+ * Map each child context to a function parameter before forming the union so a
+ * legacy `any` (normalized to `unknown` by {@link ContextType}) cannot absorb
+ * the other contexts. Inferring from the resulting contravariant parameter
+ * position converts the function union into an intersection of its contexts.
+ */
+export type ChildContext<T extends Record<string, CodecLike<any, any, any>>> = {
+  [K in keyof T]: (context: ContextType<T[K]>) => void;
+}[keyof T] extends (context: infer Context) => void
+  ? Context
+  : unknown;

package/src/codec/entity.ts

@@ -3,7 +3,7 @@ import { hashCkb } from "../hasher/index.js";
 import { Hex, hexFrom } from "../hex/index.js";
 import type { UnionDecoded, UnionMatchHandlers } from "../molecule/codec.js";
 import { Constructor } from "../utils/index.js";
-import type { CodecLike, DecodedType } from "./codec.js";
+import type { CodecLike, ContextType, DecodedType } from "./codec.js";
 
 /**
  * The base class of CCC to create a serializable instance. This should be used with the {@link codec} decorator.
@@ -15,7 +15,12 @@ export abstract class Entity {
    * This should be used with the {@link codec} decorator.
    * @public
    */
-  static Base<SubTypeLike, SubType = SubTypeLike>() {
+  static Base<
+    SubTypeLike,
+    SubType = SubTypeLike,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Context = any,
+  >() {
     abstract class Impl extends Entity {
       /**
        * The bytes length of the entity, if it is fixed, otherwise undefined
@@ -41,10 +46,11 @@ export abstract class Entity {
        * @public
        * @static
        * @param _ - The bytes to decode
+       * @param _context - Optional context passed to the codec
        * @returns The decoded entity
        * @throws Will throw an error if the entity is not serializable
        */
-      static decode(_: BytesLike): SubType {
+      static decode(_: BytesLike, _context?: Context): SubType {
         throw new Error(
           "decode not implemented, use @ccc.codec to decorate your type",
         );
@@ -55,10 +61,11 @@ export abstract class Entity {
        * @public
        * @static
        * @param _ - The bytes to create the entity from
+       * @param _context - Optional context passed to the codec
        * @returns The created entity
        * @throws Will throw an error if the entity is not serializable
        */
-      static fromBytes(_bytes: BytesLike): SubType {
+      static fromBytes(_bytes: BytesLike, _context?: Context): SubType {
         throw new Error(
           "fromBytes not implemented, use @ccc.codec to decorate your type",
         );
@@ -181,14 +188,18 @@ export abstract class Entity {
    */
   static BaseUnion<
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    CodecType extends CodecLike<any, UnionDecoded<any, any>>,
+    CodecType extends CodecLike<any, UnionDecoded<any, any>, any>,
     SubTypeLike,
     SubType = SubTypeLike,
   >() {
     type Handlers<Result> = UnionMatchHandlers<CodecType, Result>;
     type Decoded = DecodedType<CodecType>;
 
-    abstract class Impl extends Entity.Base<SubTypeLike, SubType>() {
+    abstract class Impl extends Entity.Base<
+      SubTypeLike,
+      SubType,
+      ContextType<CodecType>
+    >() {
       /**
        * The inner decoded object representing the union value.
        * @public
@@ -263,12 +274,11 @@ export function codec<
   Encodable,
   TypeLike extends Encodable,
   Decoded extends TypeLike,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Context = any,
 >(codec: {
   encode: (encodable: Encodable) => Bytes;
-  decode: (
-    decodable: Bytes,
-    config?: { isExtraFieldIgnored?: boolean },
-  ) => Decoded;
+  decode: (decodable: Bytes, context?: Context) => Decoded;
   byteLength?: number;
 }) {
   return function <
@@ -277,8 +287,8 @@ export function codec<
       from(decoded: TypeLike): Type;
       byteLength?: number;
       encode(encodable: TypeLike): Bytes;
-      decode(bytesLike: BytesLike): Type;
-      fromBytes(bytes: BytesLike): Type;
+      decode(bytesLike: BytesLike, context?: Context): Type;
+      fromBytes(bytes: BytesLike, context?: Context): Type;
     },
   >(Constructor: ConstructorType, ..._: unknown[]) {
     Constructor.byteLength = codec.byteLength;
@@ -288,13 +298,13 @@ export function codec<
       };
     }
     if (Constructor.decode === undefined) {
-      Constructor.decode = function (bytesLike: BytesLike) {
-        return Constructor.from(codec.decode(bytesFrom(bytesLike)));
+      Constructor.decode = function (bytesLike: BytesLike, context?: Context) {
+        return Constructor.from(codec.decode(bytesFrom(bytesLike), context));
       };
     }
     if (Constructor.fromBytes === undefined) {
-      Constructor.fromBytes = function (bytes: BytesLike) {
-        return Constructor.from(codec.decode(bytesFrom(bytes)));
+      Constructor.fromBytes = function (bytes: BytesLike, context?: Context) {
+        return Constructor.from(codec.decode(bytesFrom(bytes), context));
       };
     }
 

package/src/fixedPoint/index.ts

@@ -30,7 +30,11 @@ export type FixedPointLike = bigint | string | number;
  */
 
 export function fixedPointToString(val: FixedPointLike, decimals = 8): string {
-  const str = fixedPointFrom(val).toString();
+  const fp = fixedPointFrom(val, decimals);
+  if (fp < 0n) {
+    return `-${fixedPointToString(-fp, decimals)}`;
+  }
+  const str = fp.toString();
   if (decimals === 0) {
     return str;
   }
@@ -65,15 +69,20 @@ export function fixedPointFrom(val: FixedPointLike, decimals = 8): FixedPoint {
     return val;
   }
 
-  const [l, r] = (
-    typeof val === "number" ? val.toFixed(decimals) : val.toString()
-  ).split(".");
-  const lVal = BigInt(l.padEnd(l.length + decimals, "0"));
-  if (r === undefined) {
-    return lVal;
+  let str = typeof val === "number" ? val.toFixed(decimals) : val.toString();
+  const isNegative = str.startsWith("-");
+  if (isNegative || str.startsWith("+")) {
+    str = str.slice(1);
+  }
+
+  const [l, r] = str.split(".");
+  const lVal = l === "" ? 0n : BigInt(l.padEnd(l.length + decimals, "0"));
+  if (r === undefined || decimals === 0) {
+    return isNegative ? -lVal : lVal;
   }
 
-  return lVal + BigInt(r.slice(0, decimals).padEnd(decimals, "0"));
+  const unsignedVal = lVal + BigInt(r.slice(0, decimals).padEnd(decimals, "0"));
+  return isNegative ? -unsignedVal : unsignedVal;
 }
 
 /**

package/src/jsonRpc/transports/webSocket.ts

@@ -209,7 +209,9 @@ export class JsonRpcTransportWebSocket implements JsonRpcTransport {
     this.disposed = true;
     const socket = this.socket;
 
-    if (!socket || socket.readyState === socket.CLOSED) return;
+    if (!socket || socket.readyState === socket.CLOSED) {
+      return;
+    }
 
     await new Promise<void>((resolve) => {
       socket.addEventListener("close", () => resolve(), { once: true });