@haneullabs/haneul 0.1.0 → 2.5.0

package/src/bcs/effects.ts

@@ -3,8 +3,9 @@
 
 import { bcs } from '@haneullabs/bcs';
 
-import { Address, ObjectDigest, Owner, HaneulObjectRef } from './bcs.js';
+import { Address, ObjectDigest, Owner, HaneulObjectRef, TypeTag } from './bcs.js';
 
+// Rust: crate./haneul-types/src/execution_status.rs (PackageUpgradeError enum)
 const PackageUpgradeError = bcs.enum('PackageUpgradeError', {
 	UnableToFetchPackage: bcs.struct('UnableToFetchPackage', { packageId: Address }),
 	NotAPackage: bcs.struct('NotAPackage', { objectId: Address }),
@@ -17,10 +18,12 @@ const PackageUpgradeError = bcs.enum('PackageUpgradeError', {
 	}),
 });
 
+// Rust: move-core-types/src/language_storage.rs
 const ModuleId = bcs.struct('ModuleId', {
 	address: Address,
 	name: bcs.string(),
 });
+// Rust: crate./haneul-types/src/execution_status.rs
 const MoveLocation = bcs.struct('MoveLocation', {
 	module: ModuleId,
 	function: bcs.u16(),
@@ -28,6 +31,7 @@ const MoveLocation = bcs.struct('MoveLocation', {
 	functionName: bcs.option(bcs.string()),
 });
 
+// Rust: crate./haneul-types/src/execution_status.rs
 const CommandArgumentError = bcs.enum('CommandArgumentError', {
 	TypeMismatch: null,
 	InvalidBCSBytes: null,
@@ -44,13 +48,22 @@ const CommandArgumentError = bcs.enum('CommandArgumentError', {
 	InvalidObjectByValue: null,
 	InvalidObjectByMutRef: null,
 	SharedObjectOperationNotAllowed: null,
+	InvalidArgumentArity: null,
+	InvalidTransferObject: null,
+	InvalidMakeMoveVecNonObjectArgument: null,
+	ArgumentWithoutValue: null,
+	CannotMoveBorrowedValue: null,
+	CannotWriteToExtendedReference: null,
+	InvalidReferenceArgument: null,
 });
 
+// Rust: crate./haneul-types/src/execution_status.rs
 const TypeArgumentError = bcs.enum('TypeArgumentError', {
 	TypeNotFound: null,
 	ConstraintNotSatisfied: null,
 });
 
+// Rust: crate./haneul-types/src/execution_status.rs
 const ExecutionFailureStatus = bcs.enum('ExecutionFailureStatus', {
 	InsufficientGas: null,
 	InvalidGasObject: null,
@@ -68,7 +81,7 @@ const ExecutionFailureStatus = bcs.enum('ExecutionFailureStatus', {
 	InsufficientCoinBalance: null,
 	CoinBalanceOverflow: null,
 	PublishErrorNonZeroAddress: null,
-	SuiMoveVerificationError: null,
+	HaneulMoveVerificationError: null,
 	MovePrimitiveRuntimeError: bcs.option(MoveLocation),
 	MoveAbort: bcs.tuple([MoveLocation, bcs.u64()]),
 	VMVerificationOrDeserializationError: null,
@@ -102,13 +115,13 @@ const ExecutionFailureStatus = bcs.enum('ExecutionFailureStatus', {
 		maxSize: bcs.u64(),
 	}),
 	CertificateDenied: null,
-	SuiMoveVerificationTimedout: null,
+	HaneulMoveVerificationTimedout: null,
 	SharedObjectOperationNotAllowed: null,
 	InputObjectDeleted: null,
 	ExecutionCancelledDueToSharedObjectCongestion: bcs.struct(
 		'ExecutionCancelledDueToSharedObjectCongestion',
 		{
-			congestedObjects: bcs.vector(Address),
+			congested_objects: bcs.vector(Address),
 		},
 	),
 	AddressDeniedForCoin: bcs.struct('AddressDeniedForCoin', {
@@ -117,16 +130,31 @@ const ExecutionFailureStatus = bcs.enum('ExecutionFailureStatus', {
 	}),
 	CoinTypeGlobalPause: bcs.struct('CoinTypeGlobalPause', { coinType: bcs.string() }),
 	ExecutionCancelledDueToRandomnessUnavailable: null,
+	MoveVectorElemTooBig: bcs.struct('MoveVectorElemTooBig', {
+		valueSize: bcs.u64(),
+		maxScaledSize: bcs.u64(),
+	}),
+	MoveRawValueTooBig: bcs.struct('MoveRawValueTooBig', {
+		valueSize: bcs.u64(),
+		maxScaledSize: bcs.u64(),
+	}),
+	InvalidLinkage: null,
+	InsufficientBalanceForWithdraw: null,
+	NonExclusiveWriteInputObjectModified: bcs.struct('NonExclusiveWriteInputObjectModified', {
+		id: Address,
+	}),
 });
 
-const ExecutionStatus = bcs.enum('ExecutionStatus', {
+// Rust: crate./haneul-types/src/execution_status.rs
+export const ExecutionStatus = bcs.enum('ExecutionStatus', {
 	Success: null,
-	Failed: bcs.struct('ExecutionFailed', {
+	Failure: bcs.struct('Failure', {
 		error: ExecutionFailureStatus,
 		command: bcs.option(bcs.u64()),
 	}),
 });
 
+// Rust: crate./haneul-types/src/gas.rs
 const GasCostSummary = bcs.struct('GasCostSummary', {
 	computationCost: bcs.u64(),
 	storageCost: bcs.u64(),
@@ -134,6 +162,7 @@ const GasCostSummary = bcs.struct('GasCostSummary', {
 	nonRefundableStorageFee: bcs.u64(),
 });
 
+// Rust: crate./haneul-types/src/effects/effects_v1.rs
 const TransactionEffectsV1 = bcs.struct('TransactionEffectsV1', {
 	status: ExecutionStatus,
 	executedEpoch: bcs.u64(),
@@ -152,40 +181,75 @@ const TransactionEffectsV1 = bcs.struct('TransactionEffectsV1', {
 	dependencies: bcs.vector(ObjectDigest),
 });
 
+// Rust: crate./haneul-types/src/base_types.rs
 const VersionDigest = bcs.tuple([bcs.u64(), ObjectDigest]);
 
+// Rust: crate./haneul-types/src/effects/object_change.rs
 const ObjectIn = bcs.enum('ObjectIn', {
 	NotExist: null,
 	Exist: bcs.tuple([VersionDigest, Owner]),
 });
 
+// Rust: crate./haneul-types/src/effects/object_change.rs
+const AccumulatorAddress = bcs.struct('AccumulatorAddress', {
+	address: Address,
+	// TODO: ask why this is the name
+	ty: TypeTag,
+});
+
+// Rust: crate./haneul-types/src/effects/object_change.rs
+const AccumulatorOperation = bcs.enum('AccumulatorOperation', {
+	Merge: null,
+	Split: null,
+});
+
+// Rust: crate./haneul-types/src/effects/object_change.rs
+const AccumulatorValue = bcs.enum('AccumulatorValue', {
+	Integer: bcs.u64(),
+	IntegerTuple: bcs.tuple([bcs.u64(), bcs.u64()]),
+	// NonEmpty<(u64, Digest)> in Rust - vector must have at least one element
+	EventDigest: bcs.vector(bcs.tuple([bcs.u64(), ObjectDigest])),
+});
+
+// Rust: crate./haneul-types/src/effects/object_change.rs
+const AccumulatorWriteV1 = bcs.struct('AccumulatorWriteV1', {
+	address: AccumulatorAddress,
+	operation: AccumulatorOperation,
+	value: AccumulatorValue,
+});
+
+// Rust: crate./haneul-types/src/effects/object_change.rs
 const ObjectOut = bcs.enum('ObjectOut', {
 	NotExist: null,
 	ObjectWrite: bcs.tuple([ObjectDigest, Owner]),
 	PackageWrite: VersionDigest,
+	AccumulatorWriteV1: AccumulatorWriteV1,
 });
 
+// Rust: crate./haneul-types/src/effects/mod.rs
 const IDOperation = bcs.enum('IDOperation', {
 	None: null,
 	Created: null,
 	Deleted: null,
 });
 
+// Rust: crate./haneul-types/src/effects/object_change.rs
 const EffectsObjectChange = bcs.struct('EffectsObjectChange', {
 	inputState: ObjectIn,
 	outputState: ObjectOut,
 	idOperation: IDOperation,
 });
 
-const UnchangedSharedKind = bcs.enum('UnchangedSharedKind', {
+// Rust: crate./haneul-types/src/effects/effects_v2.rs
+const UnchangedConsensusKind = bcs.enum('UnchangedConsensusKind', {
 	ReadOnlyRoot: VersionDigest,
-	// TODO: these have been renamed to MutateConsensusStreamEnded and ReadConsensusStreamEnded
-	MutateDeleted: bcs.u64(),
-	ReadDeleted: bcs.u64(),
+	MutateConsensusStreamEnded: bcs.u64(),
+	ReadConsensusStreamEnded: bcs.u64(),
 	Cancelled: bcs.u64(),
 	PerEpochConfig: null,
 });
 
+// Rust: crate./haneul-types/src/effects/effects_v2.rs
 const TransactionEffectsV2 = bcs.struct('TransactionEffectsV2', {
 	status: ExecutionStatus,
 	executedEpoch: bcs.u64(),
@@ -196,10 +260,11 @@ const TransactionEffectsV2 = bcs.struct('TransactionEffectsV2', {
 	dependencies: bcs.vector(ObjectDigest),
 	lamportVersion: bcs.u64(),
 	changedObjects: bcs.vector(bcs.tuple([Address, EffectsObjectChange])),
-	unchangedSharedObjects: bcs.vector(bcs.tuple([Address, UnchangedSharedKind])),
+	unchangedConsensusObjects: bcs.vector(bcs.tuple([Address, UnchangedConsensusKind])),
 	auxDataDigest: bcs.option(ObjectDigest),
 });
 
+// Rust: crate./haneul-types/src/effects/mod.rs
 export const TransactionEffects = bcs.enum('TransactionEffects', {
 	V1: TransactionEffectsV1,
 	V2: TransactionEffectsV2,

package/src/bcs/index.ts

@@ -10,16 +10,21 @@ import {
 	CallArg,
 	Command,
 	CompressedSignature,
+	Data,
 	GasData,
 	Intent,
 	IntentMessage,
 	IntentScope,
 	IntentVersion,
+	MoveObject,
+	MoveObjectType,
+	MovePackage,
 	MultiSig,
 	MultiSigPkMap,
 	MultiSigPublicKey,
 	ObjectArg,
 	ObjectDigest,
+	ObjectInner,
 	Owner,
 	PasskeyAuthenticator,
 	ProgrammableMoveCall,
@@ -34,16 +39,25 @@ import {
 	TransactionDataV1,
 	TransactionExpiration,
 	TransactionKind,
+	TypeOrigin,
 	TypeTag,
+	UpgradeInfo,
 } from './bcs.js';
 import { TransactionEffects } from './effects.js';
 
 export type { TypeTag } from './types.js';
 
 export { TypeTagSerializer } from './type-tag-serializer.js';
-export { BcsType, BcsStruct, BcsEnum, BcsTuple, type BcsTypeOptions } from '@haneullabs/bcs';
+export {
+	BcsType,
+	BcsStruct,
+	BcsEnum,
+	BcsTuple,
+	type BcsTypeOptions,
+	compareBcsBytes,
+} from '@haneullabs/bcs';
 
-const haneulBcs = {
+const suiBcs = {
 	...bcs,
 	U8: bcs.u8(),
 	U16: bcs.u16(),
@@ -60,14 +74,19 @@ const haneulBcs = {
 	CallArg,
 	Command,
 	CompressedSignature,
+	Data,
 	GasData,
 	Intent,
 	IntentMessage,
 	IntentScope,
 	IntentVersion,
+	MoveObject,
+	MoveObjectType,
+	MovePackage,
 	MultiSig,
 	MultiSigPkMap,
 	MultiSigPublicKey,
+	Object: ObjectInner,
 	ObjectArg,
 	ObjectDigest,
 	Owner,
@@ -85,7 +104,9 @@ const haneulBcs = {
 	TransactionEffects,
 	TransactionExpiration,
 	TransactionKind,
+	TypeOrigin,
 	TypeTag,
+	UpgradeInfo,
 };
 export {
 	pureBcsSchemaFromTypeName,
@@ -93,4 +114,4 @@ export {
 	type PureTypeName,
 } from './pure.js';
 
-export { haneulBcs as bcs };
+export { suiBcs as bcs };

package/src/bcs/pure.ts

@@ -50,7 +50,6 @@ export type ShapeFromPureTypeName<T extends PureTypeName> = T extends BasePureTy
 
 type PureTypeValidationError<T extends string> = {
 	error: `Invalid Pure type name: ${T}`;
-	// eslint-disable-next-line @typescript-eslint/ban-types
 } & {};
 
 export function pureBcsSchemaFromTypeName<T extends PureTypeName>(

package/src/bcs/types.ts

@@ -42,6 +42,18 @@ export function isPureArg(arg: any): arg is PureArg {
 	return (arg as PureArg).Pure !== undefined;
 }
 
+type Reservation = { MaxAmountU64: number | string };
+type WithdrawalTypeArg = { Balance: TypeTag };
+type WithdrawFrom = { Sender: null } | { Sponsor: null };
+type FundsWithdrawalArg = {
+	reservation: Reservation;
+	typeArg: WithdrawalTypeArg;
+	withdrawFrom: WithdrawFrom;
+};
+type FundsWithdrawalCallArg = {
+	FundsWithdrawal: FundsWithdrawalArg;
+};
+
 /**
  * An argument for the transaction. It is a 'meant' enum which expects to have
  * one of the optional properties. If not, the BCS error will be thrown while
@@ -65,7 +77,7 @@ export function isPureArg(arg: any): arg is PureArg {
  * For `Pure` arguments BCS is required. You must encode the values with BCS according
  * to the type required by the called function. Pure accepts only serialized values
  */
-export type CallArg = PureArg | ObjectCallArg;
+export type CallArg = PureArg | ObjectCallArg | FundsWithdrawalCallArg;
 
 /**
  * Kind of a TypeTag which is represented by a Move type identifier.
@@ -78,7 +90,7 @@ export type StructTag = {
 };
 
 /**
- * Sui TypeTag object. A decoupled `0x...::module::Type<???>` parameter.
+ * Haneul TypeTag object. A decoupled `0x...::module::Type<???>` parameter.
  */
 export type TypeTag =
 	| { bool: null | true }
@@ -105,9 +117,21 @@ export type GasData = {
 	budget: number;
 };
 
+type ValidDuring = {
+	minEpoch: { None: null } | { Some: number | string };
+	maxEpoch: { None: null } | { Some: number | string };
+	minTimestamp: { None: null } | { Some: number | string };
+	maxTimestamp: { None: null } | { Some: number | string };
+	chain: string;
+	nonce: number;
+};
+
 /**
  * TransactionExpiration
  *
  * Indications the expiration time for a transaction.
  */
-export type TransactionExpiration = { None: null } | { Epoch: number };
+export type TransactionExpiration =
+	| { None: null }
+	| { Epoch: number }
+	| { ValidDuring: ValidDuring };

package/src/client/client.ts

@@ -0,0 +1,73 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Simplify, UnionToIntersection } from '@haneullabs/utils';
+import { ClientCache } from './cache.js';
+import type { CoreClient } from './core.js';
+import type { ClientWithExtensions, HaneulClientTypes, HaneulClientRegistration } from './types.js';
+
+export abstract class BaseClient {
+	network: HaneulClientTypes.Network;
+	cache: ClientCache;
+	base: BaseClient;
+
+	constructor({
+		network,
+		base,
+		cache = base?.cache ?? new ClientCache(),
+	}: HaneulClientTypes.HaneulClientOptions) {
+		this.network = network;
+		this.base = base ?? this;
+		this.cache = cache;
+	}
+
+	abstract core: CoreClient;
+
+	$extend<const Registrations extends HaneulClientRegistration<this>[]>(
+		...registrations: Registrations
+	) {
+		const extensions: Record<string, unknown> = Object.fromEntries(
+			registrations.map((registration) => {
+				return [registration.name, registration.register(this)];
+			}),
+		);
+
+		const methodCache = new Map<string | symbol, Function>();
+
+		return new Proxy(this, {
+			get(target, prop, receiver) {
+				if (typeof prop === 'string' && prop in extensions) {
+					return extensions[prop];
+				}
+				const value = Reflect.get(target, prop, receiver);
+				if (typeof value === 'function') {
+					if (prop === '$extend') {
+						return value.bind(receiver);
+					}
+					if (!methodCache.has(prop)) {
+						methodCache.set(prop, value.bind(target));
+					}
+					return methodCache.get(prop);
+				}
+				return value;
+			},
+		}) as ClientWithExtensions<
+			Simplify<
+				UnionToIntersection<
+					{
+						[K in keyof Registrations]: Registrations[K] extends HaneulClientRegistration<
+							this,
+							infer Name extends string,
+							infer Extension
+						>
+							? {
+									[K2 in Name]: Extension;
+								}
+							: never;
+					}[number]
+				>
+			>,
+			this
+		>;
+	}
+}