@haneullabs/bcs 0.1.0 → 2.0.2

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@haneullabs/bcs",
-  "version": "0.1.0",
+  "version": "2.0.2",
   "description": "BCS - Canonical Binary Serialization implementation for JavaScript",
   "license": "Apache-2.0",
-  "author": "Haneul Labs <build@haneullabs.com>",
+  "author": "Haneul Labs <build@haneul-labs.com>",
   "sideEffects": false,
-  "type": "commonjs",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/cjs/index.d.ts",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
@@ -22,7 +22,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/GeunhwaJeong/haneul-ts-sdks.git"
+    "url": "git+https://github.com/GeunhwaJeong/ts-sdks.git"
   },
   "keywords": [
     "bcs",
@@ -33,41 +33,35 @@
     "serde"
   ],
   "bugs": {
-    "url": "https://github.com/GeunhwaJeong/haneul-ts-sdks/issues"
+    "url": "https://github.com/GeunhwaJeong/ts-sdks/issues"
   },
   "size-limit": [
-    {
-      "path": "dist/index.js",
-      "limit": "10 kB"
-    },
     {
       "path": "dist/index.mjs",
       "limit": "10 kB"
     }
   ],
-  "homepage": "https://sdk.haneullabs.com/bcs",
+  "homepage": "https://sdk.haneul-labs.com/bcs",
   "devDependencies": {
     "@size-limit/preset-small-lib": "^12.0.0",
     "size-limit": "^12.0.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.15",
-    "@haneullabs/build-scripts": "0.1.0"
+    "vitest": "^4.0.17"
   },
   "dependencies": {
-    "@scure/base": "^1.2.6",
-    "@haneullabs/utils": "0.1.0"
+    "@scure/base": "^2.0.0",
+    "@haneullabs/utils": "^0.3.1"
   },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
-    "dev": "pnpm build --watch",
-    "build": "build-package",
+    "build": "rm -rf dist && tsc --noEmit && tsdown",
     "test": "vitest run --typecheck",
     "test:watch": "vitest --typecheck",
     "prettier:check": "prettier -c --ignore-unknown .",
     "prettier:fix": "prettier -w --ignore-unknown .",
-    "eslint:check": "eslint --max-warnings=0 .",
-    "eslint:fix": "pnpm run eslint:check --fix",
-    "lint": "pnpm run eslint:check && pnpm run prettier:check",
-    "lint:fix": "pnpm run eslint:fix && pnpm run prettier:fix"
+    "oxlint:check": "oxlint  .",
+    "oxlint:fix": "oxlint --fix",
+    "lint": "pnpm run oxlint:check && pnpm run prettier:check",
+    "lint:fix": "pnpm run oxlint:fix && pnpm run prettier:fix"
   }
 }

package/src/bcs.ts

@@ -151,6 +151,21 @@ function vector<T extends BcsType<any>, Name extends string = `vector<${T['name'
 	});
 }
 
+/**
+ * Compares two byte arrays using lexicographic ordering.
+ * This matches Rust's Ord implementation for Vec<u8>/[u8] which is used for BTreeMap key ordering.
+ * Comparison is done byte-by-byte first, then by length if all compared bytes are equal.
+ */
+export function compareBcsBytes(a: Uint8Array, b: Uint8Array): number {
+	for (let i = 0; i < Math.min(a.length, b.length); i++) {
+		if (a[i] !== b[i]) {
+			return a[i] - b[i];
+		}
+	}
+
+	return a.length - b.length;
+}
+
 function map<K extends BcsType<any>, V extends BcsType<any>>(
 	keyType: K,
 	valueType: V,
@@ -171,18 +186,28 @@ function map<K extends BcsType<any>, V extends BcsType<any>>(
 	Map<InferBcsInput<K>, InferBcsInput<V>>,
 	`Map<${K['name']}, ${V['name']}>`
 > {
-	return bcs.vector(bcs.tuple([keyType, valueType])).transform({
+	return new BcsType({
 		name: `Map<${keyType.name}, ${valueType.name}>`,
-		input: (value: Map<InferBcsInput<K>, InferBcsInput<V>>) => {
-			return [...value.entries()];
-		},
-		output: (value) => {
+		read: (reader) => {
+			const length = reader.readULEB();
 			const result = new Map<InferBcsType<K>, InferBcsType<V>>();
-			for (const [key, val] of value) {
-				result.set(key, val);
+			for (let i = 0; i < length; i++) {
+				result.set(keyType.read(reader), valueType.read(reader));
 			}
 			return result;
 		},
+		write: (value, writer) => {
+			const entries = [...value.entries()].map(
+				([key, val]) => [keyType.serialize(key).toBytes(), val] as const,
+			);
+			entries.sort(([a], [b]) => compareBcsBytes(a, b));
+
+			writer.writeULEB(entries.length);
+			for (const [keyBytes, val] of entries) {
+				writer.writeBytes(keyBytes);
+				valueType.write(val, writer);
+			}
+		},
 	});
 }
 

package/src/index.ts

@@ -21,14 +21,16 @@ import {
 	isSerializedBcs,
 	SerializedBcs,
 } from './bcs-type.js';
-import { bcs } from './bcs.js';
+import { bcs, compareBcsBytes } from './bcs.js';
 import { BcsReader } from './reader.js';
 import type {
+	Encoding,
 	EnumInputShape,
 	EnumOutputShape,
 	EnumOutputShapeWithKeys,
 	InferBcsInput,
 	InferBcsType,
+	JoinString,
 } from './types.js';
 import { decodeStr, encodeStr, splitGenericParameters } from './utils.js';
 import type { BcsWriterOptions } from './writer.js';
@@ -37,46 +39,31 @@ import { BcsWriter } from './writer.js';
 // Re-export all encoding dependencies.
 export {
 	bcs,
-	BcsType,
-	BcsStruct,
 	BcsEnum,
+	BcsReader,
+	BcsStruct,
 	BcsTuple,
-	type BcsTypeOptions,
-	SerializedBcs,
-	isSerializedBcs,
-	toBase58,
+	BcsType,
+	BcsWriter,
+	compareBcsBytes,
+	decodeStr,
+	encodeStr,
 	fromBase58,
-	toBase64,
 	fromBase64,
-	toHex,
 	fromHex,
-	encodeStr,
-	decodeStr,
+	isSerializedBcs,
+	SerializedBcs,
 	splitGenericParameters,
-	BcsReader,
-	BcsWriter,
+	toBase58,
+	toBase64,
+	toHex,
+	type BcsTypeOptions,
 	type BcsWriterOptions,
-	type InferBcsInput,
-	type InferBcsType,
-	type EnumOutputShape,
+	type Encoding,
 	type EnumInputShape,
+	type EnumOutputShape,
 	type EnumOutputShapeWithKeys,
+	type InferBcsInput,
+	type InferBcsType,
+	type JoinString,
 };
-
-/** @deprecated use toBase58 instead */
-export const toB58 = toBase58;
-
-/** @deprecated use fromBase58 instead */
-export const fromB58 = fromBase58;
-
-/** @deprecated use toBase64 instead */
-export const toB64 = toBase64;
-
-/** @deprecated use fromBase64 instead */
-export const fromB64 = fromBase64;
-
-/** @deprecated use toHex instead */
-export const toHEX = toHex;
-
-/** @deprecated use fromHex instead */
-export const fromHEX = fromHex;

package/src/uleb.ts

@@ -34,7 +34,6 @@ export function ulebDecode(arr: number[] | Uint8Array): {
 	let shift = 0n;
 	let len = 0;
 
-	// eslint-disable-next-line no-constant-condition
 	while (true) {
 		if (len >= arr.length) {
 			throw new Error('ULEB decode error: buffer overflow');

package/dist/cjs/bcs-type.d.ts

@@ -1,127 +0,0 @@
-import { BcsReader } from './reader.js';
-import type { BcsWriterOptions } from './writer.js';
-import { BcsWriter } from './writer.js';
-import type { EnumInputShape, EnumOutputShape, JoinString } from './types.js';
-export interface BcsTypeOptions<T, Input = T, Name extends string = string> {
-    name?: Name;
-    validate?: (value: Input) => void;
-}
-export declare class BcsType<T, Input = T, const Name extends string = string> {
-    #private;
-    $inferType: T;
-    $inferInput: Input;
-    name: Name;
-    read: (reader: BcsReader) => T;
-    serializedSize: (value: Input, options?: BcsWriterOptions) => number | null;
-    validate: (value: Input) => void;
-    constructor(options: {
-        name: Name;
-        read: (reader: BcsReader) => T;
-        write: (value: Input, writer: BcsWriter) => void;
-        serialize?: (value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>;
-        serializedSize?: (value: Input) => number | null;
-        validate?: (value: Input) => void;
-    } & BcsTypeOptions<T, Input, Name>);
-    write(value: Input, writer: BcsWriter): void;
-    serialize(value: Input, options?: BcsWriterOptions): SerializedBcs<T, Input>;
-    parse(bytes: Uint8Array): T;
-    fromHex(hex: string): T;
-    fromBase58(b64: string): T;
-    fromBase64(b64: string): T;
-    transform<T2 = T, Input2 = Input, NewName extends string = Name>({ name, input, output, validate, }: {
-        input?: (val: Input2) => Input;
-        output?: (value: T) => T2;
-    } & BcsTypeOptions<T2, Input2, NewName>): BcsType<T2, Input2, NewName>;
-}
-declare const SERIALIZED_BCS_BRAND: never;
-export declare function isSerializedBcs(obj: unknown): obj is SerializedBcs<unknown>;
-export declare class SerializedBcs<T, Input = T> {
-    #private;
-    [SERIALIZED_BCS_BRAND]: boolean;
-    constructor(schema: BcsType<T, Input>, bytes: Uint8Array<ArrayBuffer>);
-    toBytes(): Uint8Array<ArrayBuffer>;
-    toHex(): string;
-    toBase64(): string;
-    toBase58(): string;
-    parse(): T;
-}
-export declare function fixedSizeBcsType<T, Input = T, const Name extends string = string>({ size, ...options }: {
-    name: Name;
-    size: number;
-    read: (reader: BcsReader) => T;
-    write: (value: Input, writer: BcsWriter) => void;
-} & BcsTypeOptions<T, Input, Name>): BcsType<T, Input, Name>;
-export declare function uIntBcsType<const Name extends string = string>({ readMethod, writeMethod, ...options }: {
-    name: Name;
-    size: number;
-    readMethod: `read${8 | 16 | 32}`;
-    writeMethod: `write${8 | 16 | 32}`;
-    maxValue: number;
-} & BcsTypeOptions<number, number, Name>): BcsType<number, number, Name>;
-export declare function bigUIntBcsType<const Name extends string = string>({ readMethod, writeMethod, ...options }: {
-    name: Name;
-    size: number;
-    readMethod: `read${64 | 128 | 256}`;
-    writeMethod: `write${64 | 128 | 256}`;
-    maxValue: bigint;
-} & BcsTypeOptions<string, string | number | bigint>): BcsType<string, string | number | bigint, Name>;
-export declare function dynamicSizeBcsType<T, Input = T, const Name extends string = string>({ serialize, ...options }: {
-    name: Name;
-    read: (reader: BcsReader) => T;
-    serialize: (value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>;
-} & BcsTypeOptions<T, Input>): BcsType<T, Input, string>;
-export declare function stringLikeBcsType<const Name extends string = string>({ toBytes, fromBytes, ...options }: {
-    name: Name;
-    toBytes: (value: string) => Uint8Array;
-    fromBytes: (bytes: Uint8Array) => string;
-    serializedSize?: (value: string) => number | null;
-} & BcsTypeOptions<string, string, Name>): BcsType<string, string, Name>;
-export declare function lazyBcsType<T, Input>(cb: () => BcsType<T, Input>): BcsType<T, Input, string>;
-export interface BcsStructOptions<T extends Record<string, BcsType<any>>, Name extends string = string> extends Omit<BcsTypeOptions<{
-    [K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never;
-}, {
-    [K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never;
-}, Name>, 'name'> {
-    name: Name;
-    fields: T;
-}
-export declare class BcsStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsType<{
-    [K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never;
-}, {
-    [K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never;
-}, Name> {
-    constructor({ name, fields, ...options }: BcsStructOptions<T, Name>);
-}
-export interface BcsEnumOptions<T extends Record<string, BcsType<any> | null>, Name extends string = string> extends Omit<BcsTypeOptions<EnumOutputShape<{
-    [K in keyof T]: T[K] extends BcsType<infer U, any, any> ? U : true;
-}>, EnumInputShape<{
-    [K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null;
-}>, Name>, 'name'> {
-    name: Name;
-    fields: T;
-}
-export declare class BcsEnum<T extends Record<string, BcsType<any> | null>, const Name extends string = string> extends BcsType<EnumOutputShape<{
-    [K in keyof T]: T[K] extends BcsType<infer U, any> ? U : true;
-}>, EnumInputShape<{
-    [K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null;
-}>, Name> {
-    constructor({ fields, ...options }: BcsEnumOptions<T, Name>);
-}
-export interface BcsTupleOptions<T extends readonly BcsType<any>[], Name extends string> extends Omit<BcsTypeOptions<{
-    -readonly [K in keyof T]: T[K] extends BcsType<infer T, any> ? T : never;
-}, {
-    [K in keyof T]: T[K] extends BcsType<any, infer T> ? T : never;
-}, Name>, 'name'> {
-    name?: Name;
-    fields: T;
-}
-export declare class BcsTuple<const T extends readonly BcsType<any>[], const Name extends string = `(${JoinString<{
-    [K in keyof T]: T[K] extends BcsType<any, any, infer T> ? T : never;
-}, ', '>})`> extends BcsType<{
-    -readonly [K in keyof T]: T[K] extends BcsType<infer T, any> ? T : never;
-}, {
-    [K in keyof T]: T[K] extends BcsType<any, infer T> ? T : never;
-}, Name> {
-    constructor({ fields, name, ...options }: BcsTupleOptions<T, Name>);
-}
-export {};