@haneullabs/haneul 0.1.0

package/src/jsonRpc/types/generated.ts

@@ -0,0 +1,1639 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ *  ######################################
+ *  ### DO NOT EDIT THIS FILE DIRECTLY ###
+ *  ######################################
+ *
+ * This file is generated from:
+ * /crates/sui-open-rpc/spec/openrpc.json
+ */
+
+export interface Balance {
+	coinObjectCount: number;
+	coinType: string;
+	lockedBalance: {
+		[key: string]: string;
+	};
+	totalBalance: string;
+}
+export interface BalanceChange {
+	/**
+	 * The amount indicate the balance value changes, negative amount means spending coin value and
+	 * positive means receiving coin value.
+	 */
+	amount: string;
+	coinType: string;
+	/** Owner of the balance change */
+	owner: ObjectOwner;
+}
+export interface Checkpoint {
+	/** Commitments to checkpoint state */
+	checkpointCommitments: CheckpointCommitment[];
+	/** Checkpoint digest */
+	digest: string;
+	/** Present only on the final checkpoint of the epoch. */
+	endOfEpochData?: EndOfEpochData | null;
+	/** Checkpoint's epoch ID */
+	epoch: string;
+	/**
+	 * The running total gas costs of all transactions included in the current epoch so far until this
+	 * checkpoint.
+	 */
+	epochRollingGasCostSummary: GasCostSummary;
+	/** Total number of transactions committed since genesis, including those in this checkpoint. */
+	networkTotalTransactions: string;
+	/** Digest of the previous checkpoint */
+	previousDigest?: string | null;
+	/** Checkpoint sequence number */
+	sequenceNumber: string;
+	/**
+	 * Timestamp of the checkpoint - number of milliseconds from the Unix epoch Checkpoint timestamps are
+	 * monotonic, but not strongly monotonic - subsequent checkpoints can have same timestamp if they
+	 * originate from the same underlining consensus commit
+	 */
+	timestampMs: string;
+	/** Transaction digests */
+	transactions: string[];
+	/** Validator Signature */
+	validatorSignature: string;
+}
+export type CheckpointCommitment = {
+	ECMHLiveObjectSetDigest: ECMHLiveObjectSetDigest;
+};
+export type CheckpointId = string | string;
+/** A claim consists of value and index_mod_4. */
+export interface Claim {
+	indexMod4: number;
+	value: string;
+}
+export interface CoinStruct {
+	balance: string;
+	coinObjectId: string;
+	coinType: string;
+	digest: string;
+	previousTransaction: string;
+	version: string;
+}
+/** RPC representation of the [Committee] type. */
+export interface CommitteeInfo {
+	epoch: string;
+	validators: [string, string][];
+}
+/** Unlike [enum Signature], [enum CompressedSignature] does not contain public key. */
+export type CompressedSignature =
+	| {
+			Ed25519: string;
+	  }
+	| {
+			Secp256k1: string;
+	  }
+	| {
+			Secp256r1: string;
+	  }
+	| {
+			ZkLogin: string;
+	  }
+	| {
+			Passkey: string;
+	  };
+/** Uses an enum to allow for future expansion of the ConsensusDeterminedVersionAssignments. */
+export type ConsensusDeterminedVersionAssignments =
+	| {
+			CancelledTransactions: [string, [string, string][]][];
+	  }
+	| {
+			CancelledTransactionsV2: [string, [[string, string], string][]][];
+	  };
+export type HaneulParsedData =
+	| {
+			dataType: 'moveObject';
+			fields: MoveStruct;
+			hasPublicTransfer: boolean;
+			type: string;
+	  }
+	| {
+			dataType: 'package';
+			disassembled: {
+				[key: string]: unknown;
+			};
+	  };
+export interface DelegatedStake {
+	stakes: StakeObject[];
+	/** Staking pool object id. */
+	stakingPool: string;
+	/** Validator's Address. */
+	validatorAddress: string;
+}
+/** Additional rguments supplied to dev inspect beyond what is allowed in today's API. */
+export interface DevInspectArgs {
+	/** The gas budget for the transaction. */
+	gasBudget?: string | null;
+	/** The gas objects used to pay for the transaction. */
+	gasObjects?: [string, string, string][] | null;
+	/** The sponsor of the gas for the transaction, might be different from the sender. */
+	gasSponsor?: string | null;
+	/** Whether to return the raw transaction data and effects. */
+	showRawTxnDataAndEffects?: boolean | null;
+	/** Whether to skip transaction checks for the transaction. */
+	skipChecks?: boolean | null;
+}
+/** The response from processing a dev inspect transaction */
+export interface DevInspectResults {
+	/**
+	 * Summary of effects that likely would be generated if the transaction is actually run. Note however,
+	 * that not all dev-inspect transactions are actually usable as transactions so it might not be
+	 * possible actually generate these effects from a normal transaction.
+	 */
+	effects: TransactionEffects;
+	/** Execution error from executing the transactions */
+	error?: string | null;
+	/** Events that likely would be generated if the transaction is actually run. */
+	events: HaneulEvent[];
+	/** The raw effects of the transaction that was dev inspected. */
+	rawEffects?: number[];
+	/** The raw transaction data that was dev inspected. */
+	rawTxnData?: number[];
+	/** Execution results (including return values) from executing the transactions */
+	results?: SuiExecutionResult[] | null;
+}
+export interface DisplayFieldsResponse {
+	data?: {
+		[key: string]: string;
+	} | null;
+	error?: ObjectResponseError | null;
+}
+export interface DryRunTransactionBlockResponse {
+	balanceChanges: BalanceChange[];
+	effects: TransactionEffects;
+	events: HaneulEvent[];
+	executionErrorSource?: string | null;
+	input: TransactionBlockData;
+	objectChanges: HaneulObjectChange[];
+	suggestedGasPrice?: string | null;
+}
+export type DynamicFieldInfo =
+	| {
+			digest: string;
+			name: DynamicFieldName;
+			objectId: string;
+			objectType: string;
+			type: DynamicFieldType;
+			version: string;
+			bcsEncoding: 'base64';
+			bcsName: string;
+	  }
+	| {
+			digest: string;
+			name: DynamicFieldName;
+			objectId: string;
+			objectType: string;
+			type: DynamicFieldType;
+			version: string;
+			bcsEncoding: 'base58';
+			bcsName: string;
+	  };
+export interface DynamicFieldName {
+	type: string;
+	value: unknown;
+}
+export type DynamicFieldType = 'DynamicField' | 'DynamicObject';
+/** The Sha256 digest of an EllipticCurveMultisetHash committing to the live object set. */
+export interface ECMHLiveObjectSetDigest {
+	digest: number[];
+}
+export interface EndOfEpochData {
+	/** Commitments to epoch specific state (e.g. live object set) */
+	epochCommitments: CheckpointCommitment[];
+	/**
+	 * next_epoch_committee is `Some` if and only if the current checkpoint is the last checkpoint of an
+	 * epoch. Therefore next_epoch_committee can be used to pick the last checkpoint of an epoch, which is
+	 * often useful to get epoch level summary stats like total gas cost of an epoch, or the total number
+	 * of transactions from genesis to the end of an epoch. The committee is stored as a vector of
+	 * validator pub key and stake pairs. The vector should be sorted based on the Committee data
+	 * structure.
+	 */
+	nextEpochCommittee: [string, string][];
+	/**
+	 * The protocol version that is in effect during the epoch that starts immediately after this
+	 * checkpoint.
+	 */
+	nextEpochProtocolVersion: string;
+}
+export type HaneulEvent =
+	| {
+			/**
+			 * Sequential event ID, ie (transaction seq number, event seq number). 1) Serves as a unique event ID
+			 * for each fullnode 2) Also serves to sequence events for the purposes of pagination and querying. A
+			 * higher id is an event seen later by that fullnode. This ID is the "cursor" for event querying.
+			 */
+			id: EventId;
+			/** Move package where this event was emitted. */
+			packageId: string;
+			/** Parsed json value of the event */
+			parsedJson: unknown;
+			/** Sender's Haneul address. */
+			sender: string;
+			/** UTC timestamp in milliseconds since epoch (1/1/1970) */
+			timestampMs?: string | null;
+			/** Move module where this event was emitted. */
+			transactionModule: string;
+			/** Move event type. */
+			type: string;
+			bcs: string;
+			bcsEncoding: 'base64';
+	  }
+	| {
+			/**
+			 * Sequential event ID, ie (transaction seq number, event seq number). 1) Serves as a unique event ID
+			 * for each fullnode 2) Also serves to sequence events for the purposes of pagination and querying. A
+			 * higher id is an event seen later by that fullnode. This ID is the "cursor" for event querying.
+			 */
+			id: EventId;
+			/** Move package where this event was emitted. */
+			packageId: string;
+			/** Parsed json value of the event */
+			parsedJson: unknown;
+			/** Sender's Haneul address. */
+			sender: string;
+			/** UTC timestamp in milliseconds since epoch (1/1/1970) */
+			timestampMs?: string | null;
+			/** Move module where this event was emitted. */
+			transactionModule: string;
+			/** Move event type. */
+			type: string;
+			bcs: string;
+			bcsEncoding: 'base58';
+	  };
+export type HaneulEventFilter =
+	/** Return all events. */
+	| {
+			All: [];
+	  } /** Return events that match any of the given filters. Only supported on event subscriptions. */
+	| {
+			Any: HaneulEventFilter[];
+	  } /** Query by sender address. */
+	| {
+			Sender: string;
+	  } /** Return events emitted by the given transaction. */
+	| {
+			Transaction: string;
+	  } /**
+	 * Return events emitted in a specified Move module. If the event is defined in Module A but emitted in
+	 * a tx with Module B, query `MoveModule` by module B returns the event. Query `MoveEventModule` by
+	 * module A returns the event too.
+	 */
+	| {
+			MoveModule: {
+				/** the module name */
+				module: string;
+				/** the Move package ID */
+				package: string;
+			};
+	  } /**
+	 * Return events with the given Move event struct name (struct tag). For example, if the event is
+	 * defined in `0xabcd::MyModule`, and named `Foo`, then the struct tag is `0xabcd::MyModule::Foo`.
+	 */
+	| {
+			MoveEventType: string;
+	  } /**
+	 * Return events with the given Move module name where the event struct is defined. If the event is
+	 * defined in Module A but emitted in a tx with Module B, query `MoveEventModule` by module A returns
+	 * the event. Query `MoveModule` by module B returns the event too.
+	 */
+	| {
+			MoveEventModule: {
+				/** the module name */
+				module: string;
+				/** the Move package ID */
+				package: string;
+			};
+	  } /** Return events emitted in [start_time, end_time] interval */
+	| {
+			TimeRange: {
+				/** right endpoint of time interval, milliseconds since epoch, exclusive */
+				endTime: string;
+				/** left endpoint of time interval, milliseconds since epoch, inclusive */
+				startTime: string;
+			};
+	  };
+/** Unique ID of a Haneul Event, the ID is a combination of transaction digest and event seq number. */
+export interface EventId {
+	eventSeq: string;
+	txDigest: string;
+}
+export type ExecuteTransactionRequestType = 'WaitForEffectsCert' | 'WaitForLocalExecution';
+export type ExecutionStatus = {
+	status: 'success' | 'failure';
+	error?: string;
+};
+/**
+ * Summary of the charges in a transaction. Storage is charged independently of computation. There are
+ * 3 parts to the storage charges: `storage_cost`: it is the charge of storage at the time the
+ * transaction is executed. The cost of storage is the number of bytes of the objects being mutated
+ * multiplied by a variable storage cost per byte `storage_rebate`: this is the amount a user gets back
+ * when manipulating an object. The `storage_rebate` is the `storage_cost` for an object minus fees.
+ * `non_refundable_storage_fee`: not all the value of the object storage cost is given back to user and
+ * there is a small fraction that is kept by the system. This value tracks that charge.
+ *
+ * When looking at a gas cost summary the amount charged to the user is
+ * `computation_cost + storage_cost - storage_rebate` and that is the amount that is deducted from the
+ * gas coins. `non_refundable_storage_fee` is collected from the objects being mutated/deleted and it
+ * is tracked by the system in storage funds.
+ *
+ * Objects deleted, including the older versions of objects mutated, have the storage field on the
+ * objects added up to a pool of "potential rebate". This rebate then is reduced by the "nonrefundable
+ * rate" such that:
+ * `potential_rebate(storage cost of deleted/mutated objects) = storage_rebate + non_refundable_storage_fee`
+ */
+export interface GasCostSummary {
+	/** Cost of computation/execution */
+	computationCost: string;
+	/** The fee for the rebate. The portion of the storage rebate kept by the system. */
+	nonRefundableStorageFee: string;
+	/** Storage cost, it's the sum of all storage cost for all objects created or mutated. */
+	storageCost: string;
+	/**
+	 * The amount of storage cost refunded to the user for all objects deleted or mutated in the
+	 * transaction.
+	 */
+	storageRebate: string;
+}
+export interface HaneulGasData {
+	budget: string;
+	owner: string;
+	payment: HaneulObjectRef[];
+	price: string;
+}
+export interface GetPastObjectRequest {
+	/** the ID of the queried object */
+	objectId: string;
+	/** the version of the queried object. */
+	version: string;
+}
+export type InputObjectKind =
+	| {
+			MovePackage: string;
+	  }
+	| {
+			ImmOrOwnedMoveObject: HaneulObjectRef;
+	  }
+	| {
+			SharedMoveObject: {
+				id: string;
+				initial_shared_version: string;
+				mutable?: boolean;
+			};
+	  };
+export interface MoveCallParams {
+	arguments: unknown[];
+	function: string;
+	module: string;
+	packageObjectId: string;
+	typeArguments?: string[];
+}
+export type HaneulMoveFunctionArgType =
+	| 'Pure'
+	| {
+			Object: ObjectValueKind;
+	  };
+export type MoveStruct =
+	| MoveValue[]
+	| {
+			fields: {
+				[key: string]: MoveValue;
+			};
+			type: string;
+	  }
+	| {
+			[key: string]: MoveValue;
+	  };
+export type MoveValue =
+	| number
+	| boolean
+	| string
+	| MoveValue[]
+	| string
+	| {
+			id: string;
+	  }
+	| MoveStruct
+	| null
+	| MoveVariant;
+export interface MoveVariant {
+	fields: {
+		[key: string]: MoveValue;
+	};
+	type: string;
+	variant: string;
+}
+/** The struct that contains signatures and public keys necessary for authenticating a MultiSig. */
+export interface MultiSig {
+	/** A bitmap that indicates the position of which public key the signature should be authenticated with. */
+	bitmap: number;
+	/**
+	 * The public key encoded with each public key with its signature scheme used along with the
+	 * corresponding weight.
+	 */
+	multisig_pk: MultiSigPublicKey;
+	/** The plain signature encoded with signature scheme. */
+	sigs: CompressedSignature[];
+}
+/**
+ * Deprecated, use [struct MultiSig] instead. The struct that contains signatures and public keys
+ * necessary for authenticating a MultiSigLegacy.
+ */
+export interface MultiSigLegacy {
+	/** A bitmap that indicates the position of which public key the signature should be authenticated with. */
+	bitmap: string;
+	/**
+	 * The public key encoded with each public key with its signature scheme used along with the
+	 * corresponding weight.
+	 */
+	multisig_pk: MultiSigPublicKeyLegacy;
+	/** The plain signature encoded with signature scheme. */
+	sigs: CompressedSignature[];
+}
+/** The struct that contains the public key used for authenticating a MultiSig. */
+export interface MultiSigPublicKey {
+	/** A list of public key and its corresponding weight. */
+	pk_map: [PublicKey, number][];
+	/**
+	 * If the total weight of the public keys corresponding to verified signatures is larger than
+	 * threshold, the MultiSig is verified.
+	 */
+	threshold: number;
+}
+/**
+ * Deprecated, use [struct MultiSigPublicKey] instead. The struct that contains the public key used for
+ * authenticating a MultiSig.
+ */
+export interface MultiSigPublicKeyLegacy {
+	/** A list of public key and its corresponding weight. */
+	pk_map: [PublicKey, number][];
+	/**
+	 * If the total weight of the public keys corresponding to verified signatures is larger than
+	 * threshold, the MultiSig is verified.
+	 */
+	threshold: number;
+}
+/**
+ * ObjectChange are derived from the object mutations in the TransactionEffect to provide richer object
+ * information.
+ */
+export type HaneulObjectChange =
+	/** Module published */
+	| {
+			digest: string;
+			modules: string[];
+			packageId: string;
+			type: 'published';
+			version: string;
+	  } /** Transfer objects to new address / wrap in another object */
+	| {
+			digest: string;
+			objectId: string;
+			objectType: string;
+			recipient: ObjectOwner;
+			sender: string;
+			type: 'transferred';
+			version: string;
+	  } /** Object mutated. */
+	| {
+			digest: string;
+			objectId: string;
+			objectType: string;
+			owner: ObjectOwner;
+			previousVersion: string;
+			sender: string;
+			type: 'mutated';
+			version: string;
+	  } /** Delete object */
+	| {
+			objectId: string;
+			objectType: string;
+			sender: string;
+			type: 'deleted';
+			version: string;
+	  } /** Wrapped object */
+	| {
+			objectId: string;
+			objectType: string;
+			sender: string;
+			type: 'wrapped';
+			version: string;
+	  } /** New object creation */
+	| {
+			digest: string;
+			objectId: string;
+			objectType: string;
+			owner: ObjectOwner;
+			sender: string;
+			type: 'created';
+			version: string;
+	  };
+export interface HaneulObjectData {
+	/**
+	 * Move object content or package content in BCS, default to be None unless
+	 * HaneulObjectDataOptions.showBcs is set to true
+	 */
+	bcs?: RawData | null;
+	/**
+	 * Move object content or package content, default to be None unless HaneulObjectDataOptions.showContent
+	 * is set to true
+	 */
+	content?: HaneulParsedData | null;
+	/** Base64 string representing the object digest */
+	digest: string;
+	/**
+	 * The Display metadata for frontend UI rendering, default to be None unless
+	 * HaneulObjectDataOptions.showContent is set to true This can also be None if the struct type does not
+	 * have Display defined See more details in <https://forums.sui.io/t/nft-object-display-proposal/4872>
+	 */
+	display?: DisplayFieldsResponse | null;
+	objectId: string;
+	/** The owner of this object. Default to be None unless HaneulObjectDataOptions.showOwner is set to true */
+	owner?: ObjectOwner | null;
+	/**
+	 * The digest of the transaction that created or last mutated this object. Default to be None unless
+	 * HaneulObjectDataOptions.showPreviousTransaction is set to true
+	 */
+	previousTransaction?: string | null;
+	/**
+	 * The amount of SUI we would rebate if this object gets deleted. This number is re-calculated each
+	 * time the object is mutated based on the present storage gas price.
+	 */
+	storageRebate?: string | null;
+	/** The type of the object. Default to be None unless HaneulObjectDataOptions.showType is set to true */
+	type?: string | null;
+	/** Object version. */
+	version: string;
+}
+export interface HaneulObjectDataOptions {
+	/** Whether to show the content in BCS format. Default to be False */
+	showBcs?: boolean;
+	/**
+	 * Whether to show the content(i.e., package content or Move struct content) of the object. Default to
+	 * be False
+	 */
+	showContent?: boolean;
+	/** Whether to show the Display metadata of the object for frontend rendering. Default to be False */
+	showDisplay?: boolean;
+	/** Whether to show the owner of the object. Default to be False */
+	showOwner?: boolean;
+	/** Whether to show the previous transaction digest of the object. Default to be False */
+	showPreviousTransaction?: boolean;
+	/** Whether to show the storage rebate of the object. Default to be False */
+	showStorageRebate?: boolean;
+	/** Whether to show the type of the object. Default to be False */
+	showType?: boolean;
+}
+export type ObjectRead =
+	/** The object exists and is found with this version */
+	| {
+			details: HaneulObjectData;
+			status: 'VersionFound';
+	  } /** The object does not exist */
+	| {
+			details: string;
+			status: 'ObjectNotExists';
+	  } /** The object is found to be deleted with this version */
+	| {
+			details: HaneulObjectRef;
+			status: 'ObjectDeleted';
+	  } /** The object exists but not found with this version */
+	| {
+			details: [string, string];
+			status: 'VersionNotFound';
+	  } /** The asked object version is higher than the latest */
+	| {
+			details: {
+				asked_version: string;
+				latest_version: string;
+				object_id: string;
+			};
+			status: 'VersionTooHigh';
+	  };
+export interface HaneulObjectRef {
+	/** Base64 string representing the object digest */
+	digest: string;
+	/** Hex code as string representing the object id */
+	objectId: string;
+	/** Object version. */
+	version: string;
+}
+export type ObjectResponseError =
+	| {
+			code: 'notExists';
+			object_id: string;
+	  }
+	| {
+			code: 'dynamicFieldNotFound';
+			parent_object_id: string;
+	  }
+	| {
+			code: 'deleted';
+			/** Base64 string representing the object digest */
+			digest: string;
+			object_id: string;
+			/** Object version. */
+			version: string;
+	  }
+	| {
+			code: 'unknown';
+	  }
+	| {
+			code: 'displayError';
+			error: string;
+	  };
+export interface HaneulObjectResponseQuery {
+	/** If None, no filter will be applied */
+	filter?: HaneulObjectDataFilter | null;
+	/** config which fields to include in the response, by default only digest is included */
+	options?: HaneulObjectDataOptions | null;
+}
+export type ObjectValueKind = 'ByImmutableReference' | 'ByMutableReference' | 'ByValue';
+export interface OwnedObjectRef {
+	owner: ObjectOwner;
+	reference: HaneulObjectRef;
+}
+export type ObjectOwner =
+	/** Object is exclusively owned by a single address, and is mutable. */
+	| {
+			AddressOwner: string;
+	  } /**
+	 * Object is exclusively owned by a single object, and is mutable. The object ID is converted to
+	 * HaneulAddress as HaneulAddress is universal.
+	 */
+	| {
+			ObjectOwner: string;
+	  } /** Object is shared, can be used by any address, and is mutable. */
+	| {
+			Shared: {
+				/** The version at which the object became shared */
+				initial_shared_version: string;
+			};
+	  }
+	| 'Immutable' /** Object is exclusively owned by a single address and sequenced via consensus. */
+	| {
+			ConsensusAddressOwner: {
+				owner: string;
+				/**
+				 * The version at which the object most recently became a consensus object. This serves the same
+				 * function as `initial_shared_version`, except it may change if the object's Owner type changes.
+				 */
+				start_version: string;
+			};
+	  };
+/**
+ * `next_cursor` points to the last item in the page; Reading with `next_cursor` will start from the
+ * next item after `next_cursor` if `next_cursor` is `Some`, otherwise it will start from the first
+ * item.
+ */
+export interface PaginatedCheckpoints {
+	data: Checkpoint[];
+	hasNextPage: boolean;
+	nextCursor?: string | null;
+}
+/**
+ * `next_cursor` points to the last item in the page; Reading with `next_cursor` will start from the
+ * next item after `next_cursor` if `next_cursor` is `Some`, otherwise it will start from the first
+ * item.
+ */
+export interface PaginatedCoins {
+	data: CoinStruct[];
+	hasNextPage: boolean;
+	nextCursor?: string | null;
+}
+/**
+ * `next_cursor` points to the last item in the page; Reading with `next_cursor` will start from the
+ * next item after `next_cursor` if `next_cursor` is `Some`, otherwise it will start from the first
+ * item.
+ */
+export interface PaginatedDynamicFieldInfos {
+	data: DynamicFieldInfo[];
+	hasNextPage: boolean;
+	nextCursor?: string | null;
+}
+/**
+ * `next_cursor` points to the last item in the page; Reading with `next_cursor` will start from the
+ * next item after `next_cursor` if `next_cursor` is `Some`, otherwise it will start from the first
+ * item.
+ */
+export interface PaginatedEvents {
+	data: HaneulEvent[];
+	hasNextPage: boolean;
+	nextCursor?: EventId | null;
+}
+/**
+ * `next_cursor` points to the last item in the page; Reading with `next_cursor` will start from the
+ * next item after `next_cursor` if `next_cursor` is `Some`, otherwise it will start from the first
+ * item.
+ */
+export interface PaginatedStrings {
+	data: string[];
+	hasNextPage: boolean;
+	nextCursor?: string | null;
+}
+/**
+ * `next_cursor` points to the last item in the page; Reading with `next_cursor` will start from the
+ * next item after `next_cursor` if `next_cursor` is `Some`, otherwise it will start from the first
+ * item.
+ */
+export interface PaginatedObjectsResponse {
+	data: HaneulObjectResponse[];
+	hasNextPage: boolean;
+	nextCursor?: string | null;
+}
+/**
+ * `next_cursor` points to the last item in the page; Reading with `next_cursor` will start from the
+ * next item after `next_cursor` if `next_cursor` is `Some`, otherwise it will start from the first
+ * item.
+ */
+export interface PaginatedTransactionResponse {
+	data: HaneulTransactionBlockResponse[];
+	hasNextPage: boolean;
+	nextCursor?: string | null;
+}
+/**
+ * An passkey authenticator with parsed fields. See field defition below. Can be initialized from
+ * [struct RawPasskeyAuthenticator].
+ */
+export interface PasskeyAuthenticator {
+	/**
+	 * `authenticatorData` is a bytearray that encodes
+	 * [Authenticator Data](https://www.w3.org/TR/webauthn-2/#sctn-authenticator-data) structure returned
+	 * by the authenticator attestation response as is.
+	 */
+	authenticator_data: number[];
+	/**
+	 * `clientDataJSON` contains a JSON-compatible UTF-8 encoded string of the client data which is passed
+	 * to the authenticator by the client during the authentication request (see
+	 * [CollectedClientData](https://www.w3.org/TR/webauthn-2/#dictdef-collectedclientdata))
+	 */
+	client_data_json: string;
+}
+export interface ProtocolConfig {
+	attributes: {
+		[key: string]: ProtocolConfigValue | null;
+	};
+	featureFlags: {
+		[key: string]: boolean;
+	};
+	maxSupportedProtocolVersion: string;
+	minSupportedProtocolVersion: string;
+	protocolVersion: string;
+}
+export type ProtocolConfigValue =
+	| {
+			u16: string;
+	  }
+	| {
+			u32: string;
+	  }
+	| {
+			u64: string;
+	  }
+	| {
+			f64: string;
+	  }
+	| {
+			bool: string;
+	  };
+export type PublicKey =
+	| {
+			Ed25519: string;
+	  }
+	| {
+			Secp256k1: string;
+	  }
+	| {
+			Secp256r1: string;
+	  }
+	| {
+			ZkLogin: string;
+	  }
+	| {
+			Passkey: string;
+	  };
+export type RPCTransactionRequestParams =
+	| {
+			transferObjectRequestParams: TransferObjectParams;
+	  }
+	| {
+			moveCallRequestParams: MoveCallParams;
+	  };
+export type RawData =
+	| {
+			bcsBytes: string;
+			dataType: 'moveObject';
+			hasPublicTransfer: boolean;
+			type: string;
+			version: string;
+	  }
+	| {
+			dataType: 'package';
+			id: string;
+			linkageTable: {
+				[key: string]: UpgradeInfo;
+			};
+			moduleMap: {
+				[key: string]: string;
+			};
+			typeOriginTable: TypeOrigin[];
+			version: string;
+	  };
+export type Signature =
+	| {
+			Ed25519HaneulSignature: string;
+	  }
+	| {
+			Secp256k1HaneulSignature: string;
+	  }
+	| {
+			Secp256r1HaneulSignature: string;
+	  };
+export type StakeObject =
+	| {
+			principal: string;
+			stakeActiveEpoch: string;
+			stakeRequestEpoch: string;
+			/** ID of the StakedSui receipt object. */
+			stakedSuiId: string;
+			status: 'Pending';
+	  }
+	| {
+			principal: string;
+			stakeActiveEpoch: string;
+			stakeRequestEpoch: string;
+			/** ID of the StakedSui receipt object. */
+			stakedSuiId: string;
+			estimatedReward: string;
+			status: 'Active';
+	  }
+	| {
+			principal: string;
+			stakeActiveEpoch: string;
+			stakeRequestEpoch: string;
+			/** ID of the StakedSui receipt object. */
+			stakedSuiId: string;
+			status: 'Unstaked';
+	  };
+export interface SuiActiveJwk {
+	epoch: string;
+	jwk: SuiJWK;
+	jwk_id: SuiJwkId;
+}
+/** An argument to a transaction in a programmable transaction block */
+export type SuiArgument =
+	| 'GasCoin' /** One of the input objects or primitive values (from `ProgrammableTransactionBlock` inputs) */
+	| {
+			Input: number;
+	  } /** The result of another transaction (from `ProgrammableTransactionBlock` transactions) */
+	| {
+			Result: number;
+	  } /**
+	 * Like a `Result` but it accesses a nested result. Currently, the only usage of this is to access a
+	 * value from a Move call with multiple return values.
+	 */
+	| {
+			NestedResult: [number, number];
+	  };
+export interface SuiAuthenticatorStateExpire {
+	min_epoch: string;
+}
+export type SuiCallArg =
+	| {
+			type: 'object';
+			digest: string;
+			objectId: string;
+			objectType: 'immOrOwnedObject';
+			version: string;
+	  }
+	| {
+			type: 'object';
+			initialSharedVersion: string;
+			mutable: boolean;
+			objectId: string;
+			objectType: 'sharedObject';
+	  }
+	| {
+			type: 'object';
+			digest: string;
+			objectId: string;
+			objectType: 'receiving';
+			version: string;
+	  }
+	| {
+			type: 'pure';
+			value: unknown;
+			valueType?: string | null;
+	  };
+export interface SuiChangeEpoch {
+	computation_charge: string;
+	epoch: string;
+	epoch_start_timestamp_ms: string;
+	storage_charge: string;
+	storage_rebate: string;
+}
+export interface CoinMetadata {
+	/** Number of decimal places the coin uses. */
+	decimals: number;
+	/** Description of the token */
+	description: string;
+	/** URL for the token logo */
+	iconUrl?: string | null;
+	/** Object id for the CoinMetadata object */
+	id?: string | null;
+	/** Name for the token */
+	name: string;
+	/** Symbol for the token */
+	symbol: string;
+}
+export type SuiEndOfEpochTransactionKind =
+	| 'AuthenticatorStateCreate'
+	| 'RandomnessStateCreate'
+	| 'CoinDenyListStateCreate'
+	| 'StoreExecutionTimeObservations'
+	| 'AccumulatorRootCreate'
+	| {
+			ChangeEpoch: SuiChangeEpoch;
+	  }
+	| {
+			AuthenticatorStateExpire: SuiAuthenticatorStateExpire;
+	  }
+	| {
+			BridgeStateCreate: string;
+	  }
+	| {
+			BridgeCommitteeUpdate: string;
+	  };
+export interface SuiExecutionResult {
+	/** The value of any arguments that were mutably borrowed. Non-mut borrowed values are not included */
+	mutableReferenceOutputs?: [SuiArgument, number[], string][];
+	/** The return values from the transaction */
+	returnValues?: [number[], string][];
+}
+export interface SuiJWK {
+	alg: string;
+	e: string;
+	kty: string;
+	n: string;
+}
+export interface SuiJwkId {
+	iss: string;
+	kid: string;
+}
+export type SuiMoveAbility = 'Copy' | 'Drop' | 'Store' | 'Key';
+export interface SuiMoveAbilitySet {
+	abilities: SuiMoveAbility[];
+}
+export interface SuiMoveAbort {
+	error_code?: string | null;
+	function?: string | null;
+	line?: number | null;
+	module_id?: string | null;
+}
+export interface SuiMoveModuleId {
+	address: string;
+	name: string;
+}
+export interface SuiMoveNormalizedEnum {
+	abilities: SuiMoveAbilitySet;
+	typeParameters: SuiMoveStructTypeParameter[];
+	variantDeclarationOrder?: string[] | null;
+	variants: {
+		[key: string]: SuiMoveNormalizedField[];
+	};
+}
+export interface SuiMoveNormalizedField {
+	name: string;
+	type: HaneulMoveNormalizedType;
+}
+export interface SuiMoveNormalizedFunction {
+	isEntry: boolean;
+	parameters: HaneulMoveNormalizedType[];
+	return: HaneulMoveNormalizedType[];
+	typeParameters: SuiMoveAbilitySet[];
+	visibility: SuiMoveVisibility;
+}
+export interface SuiMoveNormalizedModule {
+	address: string;
+	enums?: {
+		[key: string]: SuiMoveNormalizedEnum;
+	};
+	exposedFunctions: {
+		[key: string]: SuiMoveNormalizedFunction;
+	};
+	fileFormatVersion: number;
+	friends: SuiMoveModuleId[];
+	name: string;
+	structs: {
+		[key: string]: SuiMoveNormalizedStruct;
+	};
+}
+export interface SuiMoveNormalizedStruct {
+	abilities: SuiMoveAbilitySet;
+	fields: SuiMoveNormalizedField[];
+	typeParameters: SuiMoveStructTypeParameter[];
+}
+export type HaneulMoveNormalizedType =
+	| 'Bool'
+	| 'U8'
+	| 'U16'
+	| 'U32'
+	| 'U64'
+	| 'U128'
+	| 'U256'
+	| 'Address'
+	| 'Signer'
+	| {
+			Struct: {
+				address: string;
+				module: string;
+				name: string;
+				typeArguments: HaneulMoveNormalizedType[];
+			};
+	  }
+	| {
+			Vector: HaneulMoveNormalizedType;
+	  }
+	| {
+			TypeParameter: number;
+	  }
+	| {
+			Reference: HaneulMoveNormalizedType;
+	  }
+	| {
+			MutableReference: HaneulMoveNormalizedType;
+	  };
+export interface SuiMoveStructTypeParameter {
+	constraints: SuiMoveAbilitySet;
+	isPhantom: boolean;
+}
+export type SuiMoveVisibility = 'Private' | 'Public' | 'Friend';
+export type HaneulObjectDataFilter =
+	| {
+			MatchAll: HaneulObjectDataFilter[];
+	  }
+	| {
+			MatchAny: HaneulObjectDataFilter[];
+	  }
+	| {
+			MatchNone: HaneulObjectDataFilter[];
+	  } /** Query by type a specified Package. */
+	| {
+			Package: string;
+	  } /** Query by type a specified Move module. */
+	| {
+			MoveModule: {
+				/** the module name */
+				module: string;
+				/** the Move package ID */
+				package: string;
+			};
+	  } /** Query by type */
+	| {
+			StructType: string;
+	  }
+	| {
+			AddressOwner: string;
+	  }
+	| {
+			ObjectOwner: string;
+	  }
+	| {
+			ObjectId: string;
+	  }
+	| {
+			ObjectIds: string[];
+	  }
+	| {
+			Version: string;
+	  };
+export interface HaneulObjectResponse {
+	data?: HaneulObjectData | null;
+	error?: ObjectResponseError | null;
+}
+/**
+ * The transaction for calling a Move function, either an entry function or a public function (which
+ * cannot return references).
+ */
+export interface MoveCallHaneulTransaction {
+	/** The arguments to the function. */
+	arguments?: SuiArgument[];
+	/** The function to be called. */
+	function: string;
+	/** The specific module in the package containing the function. */
+	module: string;
+	/** The package containing the module and function. */
+	package: string;
+	/** The type arguments to the function. */
+	type_arguments?: string[];
+}
+/**
+ * This is the JSON-RPC type for the SUI system state object. It flattens all fields to make them
+ * top-level fields such that it as minimum dependencies to the internal data structures of the SUI
+ * system state type.
+ */
+export interface HaneulSystemStateSummary {
+	/** The list of active validators in the current epoch. */
+	activeValidators: SuiValidatorSummary[];
+	/** Map storing the number of epochs for which each validator has been below the low stake threshold. */
+	atRiskValidators: [string, string][];
+	/** The current epoch ID, starting from 0. */
+	epoch: string;
+	/** The duration of an epoch, in milliseconds. */
+	epochDurationMs: string;
+	/** Unix timestamp of the current epoch start */
+	epochStartTimestampMs: string;
+	/**
+	 * ID of the object that maps from a staking pool ID to the inactive validator that has that pool as
+	 * its staking pool.
+	 */
+	inactivePoolsId: string;
+	/** Number of inactive staking pools. */
+	inactivePoolsSize: string;
+	/**
+	 * Maximum number of active validators at any moment. We do not allow the number of validators in any
+	 * epoch to go above this.
+	 */
+	maxValidatorCount: string;
+	/** Lower-bound on the amount of stake required to become a validator. */
+	minValidatorJoiningStake: string;
+	/** ID of the object that contains the list of new validators that will join at the end of the epoch. */
+	pendingActiveValidatorsId: string;
+	/** Number of new validators that will join at the end of the epoch. */
+	pendingActiveValidatorsSize: string;
+	/** Removal requests from the validators. Each element is an index pointing to `active_validators`. */
+	pendingRemovals: string[];
+	/** The current protocol version, starting from 1. */
+	protocolVersion: string;
+	/** The reference gas price for the current epoch. */
+	referenceGasPrice: string;
+	/**
+	 * Whether the system is running in a downgraded safe mode due to a non-recoverable bug. This is set
+	 * whenever we failed to execute advance_epoch, and ended up executing advance_epoch_safe_mode. It can
+	 * be reset once we are able to successfully execute advance_epoch.
+	 */
+	safeMode: boolean;
+	/** Amount of computation rewards accumulated (and not yet distributed) during safe mode. */
+	safeModeComputationRewards: string;
+	/** Amount of non-refundable storage fee accumulated during safe mode. */
+	safeModeNonRefundableStorageFee: string;
+	/** Amount of storage rebates accumulated (and not yet burned) during safe mode. */
+	safeModeStorageRebates: string;
+	/** Amount of storage rewards accumulated (and not yet distributed) during safe mode. */
+	safeModeStorageRewards: string;
+	/** Balance of SUI set aside for stake subsidies that will be drawn down over time. */
+	stakeSubsidyBalance: string;
+	/** The amount of stake subsidy to be drawn down per epoch. This amount decays and decreases over time. */
+	stakeSubsidyCurrentDistributionAmount: string;
+	/**
+	 * The rate at which the distribution amount decays at the end of each period. Expressed in basis
+	 * points.
+	 */
+	stakeSubsidyDecreaseRate: number;
+	/**
+	 * This counter may be different from the current epoch number if in some epochs we decide to skip the
+	 * subsidy.
+	 */
+	stakeSubsidyDistributionCounter: string;
+	/** Number of distributions to occur before the distribution amount decays. */
+	stakeSubsidyPeriodLength: string;
+	/** The starting epoch in which stake subsidies start being paid out */
+	stakeSubsidyStartEpoch: string;
+	/** ID of the object that maps from staking pool's ID to the sui address of a validator. */
+	stakingPoolMappingsId: string;
+	/** Number of staking pool mappings. */
+	stakingPoolMappingsSize: string;
+	/**
+	 * The non-refundable portion of the storage fund coming from storage reinvestment, non-refundable
+	 * storage rebates and any leftover staking rewards.
+	 */
+	storageFundNonRefundableBalance: string;
+	/** The storage rebates of all the objects on-chain stored in the storage fund. */
+	storageFundTotalObjectStorageRebates: string;
+	/** The current version of the system state data structure type. */
+	systemStateVersion: string;
+	/** Total amount of stake from all active validators at the beginning of the epoch. */
+	totalStake: string;
+	/**
+	 * ID of the object that stores preactive validators, mapping their addresses to their `Validator`
+	 * structs.
+	 */
+	validatorCandidatesId: string;
+	/** Number of preactive validators. */
+	validatorCandidatesSize: string;
+	/**
+	 * A validator can have stake below `validator_low_stake_threshold` for this many epochs before being
+	 * kicked out.
+	 */
+	validatorLowStakeGracePeriod: string;
+	/**
+	 * Validators with stake amount below `validator_low_stake_threshold` are considered to have low stake
+	 * and will be escorted out of the validator set after being below this threshold for more than
+	 * `validator_low_stake_grace_period` number of epochs.
+	 */
+	validatorLowStakeThreshold: string;
+	/** A map storing the records of validator reporting each other. */
+	validatorReportRecords: [string, string[]][];
+	/**
+	 * Validators with stake below `validator_very_low_stake_threshold` will be removed immediately at
+	 * epoch change, no grace period.
+	 */
+	validatorVeryLowStakeThreshold: string;
+}
+/** A single transaction in a programmable transaction block. */
+export type HaneulTransaction =
+	/** A call to either an entry or a public Move function */
+	| {
+			MoveCall: MoveCallHaneulTransaction;
+	  } /**
+	 * `(Vec<forall T:key+store. T>, address)` It sends n-objects to the specified address. These objects
+	 * must have store (public transfer) and either the previous owner must be an address or the object
+	 * must be newly created.
+	 */
+	| {
+			TransferObjects: [SuiArgument[], SuiArgument];
+	  } /**
+	 * `(&mut Coin<T>, Vec<u64>)` -> `Vec<Coin<T>>` It splits off some amounts into a new coins with those
+	 * amounts
+	 */
+	| {
+			SplitCoins: [SuiArgument, SuiArgument[]];
+	  } /** `(&mut Coin<T>, Vec<Coin<T>>)` It merges n-coins into the first coin */
+	| {
+			MergeCoins: [SuiArgument, SuiArgument[]];
+	  } /**
+	 * Publishes a Move package. It takes the package bytes and a list of the package's transitive
+	 * dependencies to link against on-chain.
+	 */
+	| {
+			Publish: string[];
+	  } /** Upgrades a Move package */
+	| {
+			Upgrade: [string[], string, SuiArgument];
+	  } /**
+	 * `forall T: Vec<T> -> vector<T>` Given n-values of the same type, it constructs a vector. For non
+	 * objects or an empty vector, the type tag must be specified.
+	 */
+	| {
+			MakeMoveVec: [string | null, SuiArgument[]];
+	  };
+export type HaneulTransactionBlockBuilderMode = 'Commit' | 'DevInspect';
+/**
+ * This is the JSON-RPC type for the SUI validator. It flattens all inner structures to top-level
+ * fields so that they are decoupled from the internal definitions.
+ */
+export interface SuiValidatorSummary {
+	commissionRate: string;
+	description: string;
+	/** ID of the exchange rate table object. */
+	exchangeRatesId: string;
+	/** Number of exchange rates in the table. */
+	exchangeRatesSize: string;
+	gasPrice: string;
+	imageUrl: string;
+	name: string;
+	netAddress: string;
+	networkPubkeyBytes: string;
+	nextEpochCommissionRate: string;
+	nextEpochGasPrice: string;
+	nextEpochNetAddress?: string | null;
+	nextEpochNetworkPubkeyBytes?: string | null;
+	nextEpochP2pAddress?: string | null;
+	nextEpochPrimaryAddress?: string | null;
+	nextEpochProofOfPossession?: string | null;
+	nextEpochProtocolPubkeyBytes?: string | null;
+	nextEpochStake: string;
+	nextEpochWorkerAddress?: string | null;
+	nextEpochWorkerPubkeyBytes?: string | null;
+	operationCapId: string;
+	p2pAddress: string;
+	/** Pending pool token withdrawn during the current epoch, emptied at epoch boundaries. */
+	pendingPoolTokenWithdraw: string;
+	/** Pending stake amount for this epoch. */
+	pendingStake: string;
+	/** Pending stake withdrawn during the current epoch, emptied at epoch boundaries. */
+	pendingTotalSuiWithdraw: string;
+	/** Total number of pool tokens issued by the pool. */
+	poolTokenBalance: string;
+	primaryAddress: string;
+	projectUrl: string;
+	proofOfPossessionBytes: string;
+	protocolPubkeyBytes: string;
+	/** The epoch stake rewards will be added here at the end of each epoch. */
+	rewardsPool: string;
+	/** The epoch at which this pool became active. */
+	stakingPoolActivationEpoch?: string | null;
+	/** The epoch at which this staking pool ceased to be active. `None` = {pre-active, active}, */
+	stakingPoolDeactivationEpoch?: string | null;
+	/** ID of the staking pool object. */
+	stakingPoolId: string;
+	/** The total number of SUI tokens in this pool. */
+	stakingPoolSuiBalance: string;
+	suiAddress: string;
+	votingPower: string;
+	workerAddress: string;
+	workerPubkeyBytes: string;
+}
+export interface CoinSupply {
+	value: string;
+}
+export interface HaneulTransactionBlock {
+	data: TransactionBlockData;
+	txSignatures: string[];
+}
+export interface TransactionBlockBytes {
+	/** the gas objects to be used */
+	gas: HaneulObjectRef[];
+	/** objects to be used in this transaction */
+	inputObjects: InputObjectKind[];
+	/** BCS serialized transaction data bytes without its type tag, as base-64 encoded string. */
+	txBytes: string;
+}
+export type TransactionBlockData = {
+	gasData: HaneulGasData;
+	messageVersion: 'v1';
+	sender: string;
+	transaction: HaneulTransactionBlockKind;
+};
+export type TransactionEffects =
+	/** The response from processing a transaction or a certified transaction */
+	{
+		/** The abort error populated if the transaction failed with an abort code. */
+		abortError?: SuiMoveAbort | null;
+		/** ObjectRef and owner of new objects created. */
+		created?: OwnedObjectRef[];
+		/** Object Refs of objects now deleted (the old refs). */
+		deleted?: HaneulObjectRef[];
+		/** The set of transaction digests this transaction depends on. */
+		dependencies?: string[];
+		/**
+		 * The digest of the events emitted during execution, can be None if the transaction does not emit any
+		 * event.
+		 */
+		eventsDigest?: string | null;
+		/** The epoch when this transaction was executed. */
+		executedEpoch: string;
+		/**
+		 * The updated gas object reference. Have a dedicated field for convenient access. It's also included
+		 * in mutated.
+		 */
+		gasObject: OwnedObjectRef;
+		gasUsed: GasCostSummary;
+		messageVersion: 'v1';
+		/**
+		 * The version that every modified (mutated or deleted) object had before it was modified by this
+		 * transaction.
+		 */
+		modifiedAtVersions?: TransactionBlockEffectsModifiedAtVersions[];
+		/** ObjectRef and owner of mutated objects, including gas object. */
+		mutated?: OwnedObjectRef[];
+		/**
+		 * The object references of the shared objects used in this transaction. Empty if no shared objects
+		 * were used.
+		 */
+		sharedObjects?: HaneulObjectRef[];
+		/** The status of the execution */
+		status: ExecutionStatus;
+		/** The transaction digest */
+		transactionDigest: string;
+		/**
+		 * ObjectRef and owner of objects that are unwrapped in this transaction. Unwrapped objects are objects
+		 * that were wrapped into other objects in the past, and just got extracted out.
+		 */
+		unwrapped?: OwnedObjectRef[];
+		/** Object refs of objects previously wrapped in other objects but now deleted. */
+		unwrappedThenDeleted?: HaneulObjectRef[];
+		/** Object refs of objects now wrapped in other objects. */
+		wrapped?: HaneulObjectRef[];
+	};
+export interface TransactionBlockEffectsModifiedAtVersions {
+	objectId: string;
+	sequenceNumber: string;
+}
+export type HaneulTransactionBlockKind =
+	/** A system transaction that will update epoch information on-chain. */
+	| {
+			computation_charge: string;
+			epoch: string;
+			epoch_start_timestamp_ms: string;
+			kind: 'ChangeEpoch';
+			storage_charge: string;
+			storage_rebate: string;
+	  } /** A system transaction used for initializing the initial state of the chain. */
+	| {
+			kind: 'Genesis';
+			objects: string[];
+	  } /** A system transaction marking the start of a series of transactions scheduled as part of a checkpoint */
+	| {
+			commit_timestamp_ms: string;
+			epoch: string;
+			kind: 'ConsensusCommitPrologue';
+			round: string;
+	  } /** A series of transactions where the results of one transaction can be used in future transactions */
+	| {
+			/** Input objects or primitive values */
+			inputs: SuiCallArg[];
+			kind: 'ProgrammableTransaction';
+			/**
+			 * The transactions to be executed sequentially. A failure in any transaction will result in the
+			 * failure of the entire programmable transaction block.
+			 */
+			transactions: HaneulTransaction[];
+	  } /** A transaction which updates global authenticator state */
+	| {
+			epoch: string;
+			kind: 'AuthenticatorStateUpdate';
+			new_active_jwks: SuiActiveJwk[];
+			round: string;
+	  } /** A transaction which updates global randomness state */
+	| {
+			epoch: string;
+			kind: 'RandomnessStateUpdate';
+			random_bytes: number[];
+			randomness_round: string;
+	  } /** The transaction which occurs only at the end of the epoch */
+	| {
+			kind: 'EndOfEpochTransaction';
+			transactions: SuiEndOfEpochTransactionKind[];
+	  }
+	| {
+			commit_timestamp_ms: string;
+			consensus_commit_digest: string;
+			epoch: string;
+			kind: 'ConsensusCommitPrologueV2';
+			round: string;
+	  }
+	| {
+			commit_timestamp_ms: string;
+			consensus_commit_digest: string;
+			consensus_determined_version_assignments: ConsensusDeterminedVersionAssignments;
+			epoch: string;
+			kind: 'ConsensusCommitPrologueV3';
+			round: string;
+			sub_dag_index?: string | null;
+	  }
+	| {
+			additional_state_digest: string;
+			commit_timestamp_ms: string;
+			consensus_commit_digest: string;
+			consensus_determined_version_assignments: ConsensusDeterminedVersionAssignments;
+			epoch: string;
+			kind: 'ConsensusCommitPrologueV4';
+			round: string;
+			sub_dag_index?: string | null;
+	  } /** A series of commands where the results of one command can be used in future commands */
+	| {
+			/** Input objects or primitive values */
+			inputs: SuiCallArg[];
+			kind: 'ProgrammableSystemTransaction';
+			/**
+			 * The transactions to be executed sequentially. A failure in any transaction will result in the
+			 * failure of the entire programmable transaction block.
+			 */
+			transactions: HaneulTransaction[];
+	  };
+export interface HaneulTransactionBlockResponse {
+	balanceChanges?: BalanceChange[] | null;
+	/**
+	 * The checkpoint number when this transaction was included and hence finalized. This is only returned
+	 * in the read api, not in the transaction execution api.
+	 */
+	checkpoint?: string | null;
+	confirmedLocalExecution?: boolean | null;
+	digest: string;
+	effects?: TransactionEffects | null;
+	errors?: string[];
+	events?: HaneulEvent[] | null;
+	objectChanges?: HaneulObjectChange[] | null;
+	rawEffects?: number[];
+	/**
+	 * BCS encoded [SenderSignedData] that includes input object references returns empty array if
+	 * `show_raw_transaction` is false
+	 */
+	rawTransaction?: string;
+	timestampMs?: string | null;
+	/** Transaction input data */
+	transaction?: HaneulTransactionBlock | null;
+}
+export interface HaneulTransactionBlockResponseOptions {
+	/** Whether to show balance_changes. Default to be False */
+	showBalanceChanges?: boolean;
+	/** Whether to show transaction effects. Default to be False */
+	showEffects?: boolean;
+	/** Whether to show transaction events. Default to be False */
+	showEvents?: boolean;
+	/** Whether to show transaction input data. Default to be False */
+	showInput?: boolean;
+	/** Whether to show object_changes. Default to be False */
+	showObjectChanges?: boolean;
+	/** Whether to show raw transaction effects. Default to be False */
+	showRawEffects?: boolean;
+	/** Whether to show bcs-encoded transaction input data */
+	showRawInput?: boolean;
+}
+export interface HaneulTransactionBlockResponseQuery {
+	/** If None, no filter will be applied */
+	filter?: TransactionFilter | null;
+	/** config which fields to include in the response, by default only digest is included */
+	options?: HaneulTransactionBlockResponseOptions | null;
+}
+export type TransactionFilter =
+	/** CURRENTLY NOT SUPPORTED. Query by checkpoint. */
+	| {
+			Checkpoint: string;
+	  } /** Query by move function. */
+	| {
+			MoveFunction: {
+				function?: string | null;
+				module?: string | null;
+				package: string;
+			};
+	  } /** Query by input object. */
+	| {
+			InputObject: string;
+	  } /** Query by changed object, including created, mutated and unwrapped objects. */
+	| {
+			ChangedObject: string;
+	  } /** Query for transactions that touch this object. */
+	| {
+			AffectedObject: string;
+	  } /** Query by sender address. */
+	| {
+			FromAddress: string;
+	  } /** Query by recipient address. */
+	| {
+			ToAddress: string;
+	  } /** Query by sender and recipient address. */
+	| {
+			FromAndToAddress: {
+				from: string;
+				to: string;
+			};
+	  } /** CURRENTLY NOT SUPPORTED. Query txs that have a given address as sender or recipient. */
+	| {
+			FromOrToAddress: {
+				addr: string;
+			};
+	  } /** Query by transaction kind */
+	| {
+			TransactionKind: string;
+	  } /** Query transactions of any given kind in the input. */
+	| {
+			TransactionKindIn: string[];
+	  };
+export interface TransferObjectParams {
+	objectId: string;
+	recipient: string;
+}
+/** Identifies a struct and the module it was defined in */
+export interface TypeOrigin {
+	datatype_name: string;
+	module_name: string;
+	package: string;
+}
+/** Upgraded package info for the linkage table */
+export interface UpgradeInfo {
+	/** ID of the upgraded packages */
+	upgraded_id: string;
+	/** Version of the upgraded package */
+	upgraded_version: string;
+}
+export interface ValidatorApy {
+	address: string;
+	apy: number;
+}
+export interface ValidatorsApy {
+	apys: ValidatorApy[];
+	epoch: string;
+}
+/** An zk login authenticator with all the necessary fields. */
+export interface ZkLoginAuthenticator {
+	inputs: ZkLoginInputs;
+	maxEpoch: string;
+	userSignature: Signature;
+}
+/** All inputs required for the zk login proof verification and other public inputs. */
+export interface ZkLoginInputs {
+	addressSeed: string;
+	headerBase64: string;
+	issBase64Details: Claim;
+	proofPoints: ZkLoginProof;
+}
+export type ZkLoginIntentScope = 'TransactionData' | 'PersonalMessage';
+/** The struct for zk login proof. */
+export interface ZkLoginProof {
+	a: string[];
+	b: string[][];
+	c: string[];
+}
+export interface ZkLoginVerifyResult {
+	/** The errors field captures any verification error */
+	errors: string[];
+	/** The boolean result of the verification. If true, errors should be empty. */
+	success: boolean;
+}