@haneullabs/haneul 0.1.0

package/package.json

@@ -0,0 +1,196 @@
+{
+  "name": "@haneullabs/haneul",
+  "author": "Haneul Labs <build@haneullabs.com>",
+  "description": "Haneul TypeScript API",
+  "homepage": "https://sdk.haneullabs.com",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "bcs",
+    "builder",
+    "client",
+    "cryptography",
+    "dist",
+    "experimental",
+    "faucet",
+    "graphql",
+    "grpc",
+    "jsonRpc",
+    "keypairs",
+    "multisig",
+    "src",
+    "transactions",
+    "utils",
+    "verify",
+    "zklogin"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "commonjs",
+  "exports": {
+    "./bcs": {
+      "import": "./dist/esm/bcs/index.js",
+      "require": "./dist/cjs/bcs/index.js"
+    },
+    "./client": {
+      "import": "./dist/esm/client/index.js",
+      "require": "./dist/cjs/client/index.js"
+    },
+    "./cryptography": {
+      "import": "./dist/esm/cryptography/index.js",
+      "require": "./dist/cjs/cryptography/index.js"
+    },
+    "./experimental": {
+      "import": "./dist/esm/experimental/index.js",
+      "require": "./dist/cjs/experimental/index.js"
+    },
+    "./faucet": {
+      "import": "./dist/esm/faucet/index.js",
+      "require": "./dist/cjs/faucet/index.js"
+    },
+    "./graphql": {
+      "import": "./dist/esm/graphql/index.js",
+      "require": "./dist/cjs/graphql/index.js"
+    },
+    "./grpc": {
+      "import": "./dist/esm/grpc/index.js",
+      "require": "./dist/cjs/grpc/index.js"
+    },
+    "./jsonRpc": {
+      "import": "./dist/esm/jsonRpc/index.js",
+      "require": "./dist/cjs/jsonRpc/index.js"
+    },
+    "./keypairs/ed25519": {
+      "import": "./dist/esm/keypairs/ed25519/index.js",
+      "require": "./dist/cjs/keypairs/ed25519/index.js"
+    },
+    "./keypairs/secp256k1": {
+      "import": "./dist/esm/keypairs/secp256k1/index.js",
+      "require": "./dist/cjs/keypairs/secp256k1/index.js"
+    },
+    "./keypairs/secp256r1": {
+      "import": "./dist/esm/keypairs/secp256r1/index.js",
+      "require": "./dist/cjs/keypairs/secp256r1/index.js"
+    },
+    "./keypairs/passkey": {
+      "import": "./dist/esm/keypairs/passkey/index.js",
+      "require": "./dist/cjs/keypairs/passkey/index.js"
+    },
+    "./multisig": {
+      "import": "./dist/esm/multisig/index.js",
+      "require": "./dist/cjs/multisig/index.js"
+    },
+    "./transactions": {
+      "import": "./dist/esm/transactions/index.js",
+      "require": "./dist/cjs/transactions/index.js"
+    },
+    "./utils": {
+      "import": "./dist/esm/utils/index.js",
+      "require": "./dist/cjs/utils/index.js"
+    },
+    "./verify": {
+      "import": "./dist/esm/verify/index.js",
+      "require": "./dist/cjs/verify/index.js"
+    },
+    "./zklogin": {
+      "import": "./dist/esm/zklogin/index.js",
+      "require": "./dist/cjs/zklogin/index.js"
+    },
+    "./graphql/schemas/2024.1": {
+      "import": "./dist/esm/graphql/schemas/2024.1/index.js",
+      "require": "./dist/cjs/graphql/schemas/2024.1/index.js"
+    },
+    "./graphql/schemas/2024.4": {
+      "import": "./dist/esm/graphql/schemas/2024.4/index.js",
+      "require": "./dist/cjs/graphql/schemas/2024.4/index.js"
+    },
+    "./graphql/schemas/latest": {
+      "import": "./dist/esm/graphql/schemas/latest/index.js",
+      "require": "./dist/cjs/graphql/schemas/latest/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GeunhwaJeong/haneul-ts-sdks.git"
+  },
+  "bugs": {
+    "url": "https://github.com/GeunhwaJeong/haneul-ts-sdks/issues/new"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@0no-co/graphqlsp": "^1.15.1",
+    "@graphql-codegen/add": "^6.0.0",
+    "@graphql-codegen/cli": "^6.1.0",
+    "@graphql-codegen/typed-document-node": "^6.1.4",
+    "@graphql-codegen/typescript": "5.0.6",
+    "@graphql-codegen/typescript-document-nodes": "5.0.6",
+    "@graphql-codegen/typescript-operations": "^5.0.6",
+    "@iarna/toml": "^2.2.5",
+    "@parcel/watcher": "^2.5.1",
+    "@types/node": "^24.10.1",
+    "@types/tmp": "^0.2.6",
+    "@types/ws": "^8.18.1",
+    "cross-env": "^10.1.0",
+    "graphql-config": "^5.1.5",
+    "msw": "^2.12.3",
+    "tmp": "^0.2.5",
+    "ts-retry-promise": "^0.8.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.6",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^4.0.15",
+    "wait-on": "^9.0.3",
+    "ws": "^8.18.3",
+    "@haneullabs/build-scripts": "^0.1.0"
+  },
+  "dependencies": {
+    "@graphql-typed-document-node/core": "^3.2.0",
+    "@noble/curves": "=1.9.4",
+    "@noble/hashes": "^1.8.0",
+    "@protobuf-ts/grpcweb-transport": "^2.11.1",
+    "@protobuf-ts/runtime": "^2.11.1",
+    "@protobuf-ts/runtime-rpc": "^2.11.1",
+    "@scure/base": "^1.2.6",
+    "@scure/bip32": "^1.7.0",
+    "@scure/bip39": "^1.6.0",
+    "gql.tada": "^1.9.0",
+    "graphql": "^16.12.0",
+    "poseidon-lite": "0.2.1",
+    "valibot": "^1.2.0",
+    "@haneullabs/bcs": "0.1.0",
+    "@haneullabs/utils": "0.1.0"
+  },
+  "scripts": {
+    "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
+    "codegen": "pnpm codegen:graphql && pnpm codegen:grpc && pnpm lint:fix",
+    "codegen:graphql": "graphql-codegen --config graphql-codegen.ts",
+    "codegen:version": "node genversion.mjs",
+    "codegen:grpc": "rm -rf src/grpc/proto && mkdir src/grpc/proto && pnpm codegen:grpc-protoc && pnpm codegen:grpc-header",
+    "codegen:grpc-protoc": "protoc --ts_out ./src/grpc/proto --ts_opt force_server_none --ts_opt optimize_code_size --ts_opt ts_nocheck -I ../../../sui-apis/proto -I ../../../sui-apis/proto ../../../sui-apis/proto/sui/rpc/v2/*.proto ../../../sui-apis/proto/google/*/*.proto",
+    "codegen:grpc-header": "find src/grpc/proto -type f -exec sh -c 'echo \"// Copyright (c) Haneul Labs, Inc.\\n// SPDX-License-Identifier: Apache-2.0\\n\" | cat - {} > temp && mv temp {}' \\;",
+    "build": "node genversion.mjs && pnpm build:package",
+    "build:package": "build-package",
+    "vitest": "vitest",
+    "test": "pnpm test:typecheck && pnpm test:unit",
+    "test:typecheck": "tsc -p ./test",
+    "test:unit": "vitest run unit __tests__",
+    "test:e2e": "vitest run --config test/e2e/vitest.config.mts",
+    "size": "size-limit",
+    "analyze": "size-limit --why",
+    "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",
+    "update-schemas": "pnpm tsx scripts/update-graphql-schemas.ts",
+    "generate-schema": "gql.tada generate-output"
+  }
+}

package/src/bcs/bcs.ts

@@ -0,0 +1,321 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { BcsType, BcsTypeOptions } from '@haneullabs/bcs';
+import { bcs, fromBase58, fromBase64, fromHex, toBase58, toBase64, toHex } from '@haneullabs/bcs';
+
+import { isValidHaneulAddress, normalizeHaneulAddress, HANEUL_ADDRESS_LENGTH } from '../utils/haneul-types.js';
+import { TypeTagSerializer } from './type-tag-serializer.js';
+import type { TypeTag as TypeTagType } from './types.js';
+
+function unsafe_u64(options?: BcsTypeOptions<number>) {
+	return bcs
+		.u64({
+			name: 'unsafe_u64',
+			...(options as object),
+		})
+		.transform({
+			input: (val: number | string) => val,
+			output: (val) => Number(val),
+		});
+}
+
+function optionEnum<T extends BcsType<any, any>>(type: T) {
+	return bcs.enum('Option', {
+		None: null,
+		Some: type,
+	});
+}
+
+export const Address = bcs.bytes(HANEUL_ADDRESS_LENGTH).transform({
+	validate: (val) => {
+		const address = typeof val === 'string' ? val : toHex(val);
+		if (!address || !isValidHaneulAddress(normalizeHaneulAddress(address))) {
+			throw new Error(`Invalid Haneul address ${address}`);
+		}
+	},
+	input: (val: string | Uint8Array) =>
+		typeof val === 'string' ? fromHex(normalizeHaneulAddress(val)) : val,
+	output: (val) => normalizeHaneulAddress(toHex(val)),
+});
+
+export const ObjectDigest = bcs.byteVector().transform({
+	name: 'ObjectDigest',
+	input: (value: string) => fromBase58(value),
+	output: (value) => toBase58(new Uint8Array(value)),
+	validate: (value) => {
+		if (fromBase58(value).length !== 32) {
+			throw new Error('ObjectDigest must be 32 bytes');
+		}
+	},
+});
+
+export const HaneulObjectRef = bcs.struct('HaneulObjectRef', {
+	objectId: Address,
+	version: bcs.u64(),
+	digest: ObjectDigest,
+});
+
+export const SharedObjectRef = bcs.struct('SharedObjectRef', {
+	objectId: Address,
+	initialSharedVersion: bcs.u64(),
+	mutable: bcs.bool(),
+});
+
+export const ObjectArg = bcs.enum('ObjectArg', {
+	ImmOrOwnedObject: HaneulObjectRef,
+	SharedObject: SharedObjectRef,
+	Receiving: HaneulObjectRef,
+});
+
+export const Owner = bcs.enum('Owner', {
+	AddressOwner: Address,
+	ObjectOwner: Address,
+	Shared: bcs.struct('Shared', {
+		initialSharedVersion: bcs.u64(),
+	}),
+	Immutable: null,
+	ConsensusAddressOwner: bcs.struct('ConsensusAddressOwner', {
+		owner: Address,
+		startVersion: bcs.u64(),
+	}),
+});
+
+export const CallArg = bcs.enum('CallArg', {
+	Pure: bcs.struct('Pure', {
+		bytes: bcs.byteVector().transform({
+			input: (val: string | Uint8Array) => (typeof val === 'string' ? fromBase64(val) : val),
+			output: (val) => toBase64(new Uint8Array(val)),
+		}),
+	}),
+	Object: ObjectArg,
+});
+
+const InnerTypeTag: BcsType<TypeTagType, TypeTagType> = bcs.enum('TypeTag', {
+	bool: null,
+	u8: null,
+	u64: null,
+	u128: null,
+	address: null,
+	signer: null,
+	vector: bcs.lazy(() => InnerTypeTag),
+	struct: bcs.lazy(() => StructTag),
+	u16: null,
+	u32: null,
+	u256: null,
+}) as BcsType<TypeTagType>;
+
+export const TypeTag = InnerTypeTag.transform({
+	input: (typeTag: string | TypeTagType) =>
+		typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag, true) : typeTag,
+	output: (typeTag: TypeTagType) => TypeTagSerializer.tagToString(typeTag),
+});
+
+export const Argument = bcs.enum('Argument', {
+	GasCoin: null,
+	Input: bcs.u16(),
+	Result: bcs.u16(),
+	NestedResult: bcs.tuple([bcs.u16(), bcs.u16()]),
+});
+
+export const ProgrammableMoveCall = bcs.struct('ProgrammableMoveCall', {
+	package: Address,
+	module: bcs.string(),
+	function: bcs.string(),
+	typeArguments: bcs.vector(TypeTag),
+	arguments: bcs.vector(Argument),
+});
+
+export const Command = bcs.enum('Command', {
+	/**
+	 * A Move Call - any public Move function can be called via
+	 * this transaction. The results can be used that instant to pass
+	 * into the next transaction.
+	 */
+	MoveCall: ProgrammableMoveCall,
+	/**
+	 * Transfer vector of objects to a receiver.
+	 */
+	TransferObjects: bcs.struct('TransferObjects', {
+		objects: bcs.vector(Argument),
+		address: Argument,
+	}),
+	// /**
+	//  * Split `amount` from a `coin`.
+	//  */
+	SplitCoins: bcs.struct('SplitCoins', {
+		coin: Argument,
+		amounts: bcs.vector(Argument),
+	}),
+	// /**
+	//  * Merge Vector of Coins (`sources`) into a `destination`.
+	//  */
+	MergeCoins: bcs.struct('MergeCoins', {
+		destination: Argument,
+		sources: bcs.vector(Argument),
+	}),
+	// /**
+	//  * Publish a Move module.
+	//  */
+	Publish: bcs.struct('Publish', {
+		modules: bcs.vector(
+			bcs.byteVector().transform({
+				input: (val: string | Uint8Array) => (typeof val === 'string' ? fromBase64(val) : val),
+				output: (val) => toBase64(new Uint8Array(val)),
+			}),
+		),
+		dependencies: bcs.vector(Address),
+	}),
+	// /**
+	//  * Build a vector of objects using the input arguments.
+	//  * It is impossible to export construct a `vector<T: key>` otherwise,
+	//  * so this call serves a utility function.
+	//  */
+	MakeMoveVec: bcs.struct('MakeMoveVec', {
+		type: optionEnum(TypeTag).transform({
+			input: (val: string | null) =>
+				val === null
+					? {
+							None: true,
+						}
+					: {
+							Some: val,
+						},
+			output: (val) => val.Some ?? null,
+		}),
+		elements: bcs.vector(Argument),
+	}),
+	Upgrade: bcs.struct('Upgrade', {
+		modules: bcs.vector(
+			bcs.byteVector().transform({
+				input: (val: string | Uint8Array) => (typeof val === 'string' ? fromBase64(val) : val),
+				output: (val) => toBase64(new Uint8Array(val)),
+			}),
+		),
+		dependencies: bcs.vector(Address),
+		package: Address,
+		ticket: Argument,
+	}),
+});
+
+export const ProgrammableTransaction = bcs.struct('ProgrammableTransaction', {
+	inputs: bcs.vector(CallArg),
+	commands: bcs.vector(Command),
+});
+
+export const TransactionKind = bcs.enum('TransactionKind', {
+	ProgrammableTransaction: ProgrammableTransaction,
+	ChangeEpoch: null,
+	Genesis: null,
+	ConsensusCommitPrologue: null,
+});
+
+export const TransactionExpiration = bcs.enum('TransactionExpiration', {
+	None: null,
+	Epoch: unsafe_u64(),
+});
+
+export const StructTag = bcs.struct('StructTag', {
+	address: Address,
+	module: bcs.string(),
+	name: bcs.string(),
+	typeParams: bcs.vector(InnerTypeTag),
+});
+
+export const GasData = bcs.struct('GasData', {
+	payment: bcs.vector(HaneulObjectRef),
+	owner: Address,
+	price: bcs.u64(),
+	budget: bcs.u64(),
+});
+
+export const TransactionDataV1 = bcs.struct('TransactionDataV1', {
+	kind: TransactionKind,
+	sender: Address,
+	gasData: GasData,
+	expiration: TransactionExpiration,
+});
+
+export const TransactionData = bcs.enum('TransactionData', {
+	V1: TransactionDataV1,
+});
+
+export const IntentScope = bcs.enum('IntentScope', {
+	TransactionData: null,
+	TransactionEffects: null,
+	CheckpointSummary: null,
+	PersonalMessage: null,
+});
+
+export const IntentVersion = bcs.enum('IntentVersion', {
+	V0: null,
+});
+
+export const AppId = bcs.enum('AppId', {
+	Sui: null,
+});
+
+export const Intent = bcs.struct('Intent', {
+	scope: IntentScope,
+	version: IntentVersion,
+	appId: AppId,
+});
+
+export function IntentMessage<T extends BcsType<any>>(T: T) {
+	return bcs.struct(`IntentMessage<${T.name}>`, {
+		intent: Intent,
+		value: T,
+	});
+}
+
+export const CompressedSignature = bcs.enum('CompressedSignature', {
+	ED25519: bcs.bytes(64),
+	Secp256k1: bcs.bytes(64),
+	Secp256r1: bcs.bytes(64),
+	ZkLogin: bcs.byteVector(),
+	Passkey: bcs.byteVector(),
+});
+
+export const PublicKey = bcs.enum('PublicKey', {
+	ED25519: bcs.bytes(32),
+	Secp256k1: bcs.bytes(33),
+	Secp256r1: bcs.bytes(33),
+	ZkLogin: bcs.byteVector(),
+	Passkey: bcs.bytes(33),
+});
+
+export const MultiSigPkMap = bcs.struct('MultiSigPkMap', {
+	pubKey: PublicKey,
+	weight: bcs.u8(),
+});
+
+export const MultiSigPublicKey = bcs.struct('MultiSigPublicKey', {
+	pk_map: bcs.vector(MultiSigPkMap),
+	threshold: bcs.u16(),
+});
+
+export const MultiSig = bcs.struct('MultiSig', {
+	sigs: bcs.vector(CompressedSignature),
+	bitmap: bcs.u16(),
+	multisig_pk: MultiSigPublicKey,
+});
+
+export const base64String = bcs.byteVector().transform({
+	input: (val: string | Uint8Array) => (typeof val === 'string' ? fromBase64(val) : val),
+	output: (val) => toBase64(new Uint8Array(val)),
+});
+
+export const SenderSignedTransaction = bcs.struct('SenderSignedTransaction', {
+	intentMessage: IntentMessage(TransactionData),
+	txSignatures: bcs.vector(base64String),
+});
+
+export const SenderSignedData = bcs.vector(SenderSignedTransaction, {
+	name: 'SenderSignedData',
+});
+
+export const PasskeyAuthenticator = bcs.struct('PasskeyAuthenticator', {
+	authenticatorData: bcs.byteVector(),
+	clientDataJson: bcs.string(),
+	userSignature: bcs.byteVector(),
+});