@haneullabs/haneul 0.1.0

package/src/faucet/faucet.ts

@@ -0,0 +1,189 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export class FaucetRateLimitError extends Error {}
+
+type FaucetCoinInfo = {
+	amount: number;
+	id: string;
+	transferTxDigest: string;
+};
+
+type FaucetResponse = {
+	transferredGasObjects: FaucetCoinInfo[];
+	error?: string | null;
+};
+
+type BatchFaucetResponse = {
+	task?: string | null;
+	error?: string | null;
+};
+
+type BatchSendStatusType = {
+	status: 'INPROGRESS' | 'SUCCEEDED' | 'DISCARDED';
+	transferred_gas_objects: { sent: FaucetCoinInfo[] };
+};
+
+type BatchStatusFaucetResponse = {
+	status: BatchSendStatusType;
+	error?: string | null;
+};
+
+type FaucetResponseV2 = {
+	status: 'Success' | FaucetFailure;
+	coins_sent: FaucetCoinInfo[] | null;
+};
+
+type FaucetFailure = {
+	Failure: {
+		internal: string;
+	};
+};
+
+type FaucetRequest = {
+	host: string;
+	path: string;
+	body?: Record<string, any>;
+	headers?: HeadersInit;
+	method: 'GET' | 'POST';
+};
+
+async function faucetRequest<T>({ host, path, body, headers, method }: FaucetRequest): Promise<T> {
+	const endpoint = new URL(path, host).toString();
+	const res = await fetch(endpoint, {
+		method,
+		body: body ? JSON.stringify(body) : undefined,
+		headers: {
+			'Content-Type': 'application/json',
+			...headers,
+		},
+	});
+
+	if (res.status === 429) {
+		throw new FaucetRateLimitError(
+			`Too many requests from this client have been sent to the faucet. Please retry later`,
+		);
+	}
+
+	try {
+		const parsed = await res.json();
+		return parsed as T;
+	} catch (e) {
+		throw new Error(
+			`Encountered error when parsing response from faucet, error: ${e}, status ${res.status}, response ${res}`,
+		);
+	}
+}
+
+/**
+ * @deprecated "Use requestHaneulFromFaucetV2 instead"
+ */
+export async function requestHaneulFromFaucetV0(input: {
+	host: string;
+	recipient: string;
+	headers?: HeadersInit;
+}): Promise<FaucetResponse> {
+	const response = await faucetRequest<FaucetResponse>({
+		host: input.host,
+		path: '/gas',
+		body: {
+			FixedAmountRequest: {
+				recipient: input.recipient,
+			},
+		},
+		headers: input.headers,
+		method: 'POST',
+	});
+
+	if (response.error) {
+		throw new Error(`Faucet request failed: ${response.error}`);
+	}
+
+	return response;
+}
+
+/**
+ * @deprecated "Use requestHaneulFromFaucetV2 instead"
+ */
+export async function requestHaneulFromFaucetV1(input: {
+	host: string;
+	recipient: string;
+	headers?: HeadersInit;
+}): Promise<BatchFaucetResponse> {
+	const response = await faucetRequest<BatchFaucetResponse>({
+		host: input.host,
+		path: '/v1/gas',
+		body: {
+			FixedAmountRequest: {
+				recipient: input.recipient,
+			},
+		},
+		headers: input.headers,
+		method: 'POST',
+	});
+
+	if (response.error) {
+		throw new Error(`Faucet request failed: ${response.error}`);
+	}
+
+	return response;
+}
+
+export async function requestHaneulFromFaucetV2(input: {
+	host: string;
+	recipient: string;
+	headers?: HeadersInit;
+}) {
+	const response = await faucetRequest<FaucetResponseV2>({
+		host: input.host,
+		path: '/v2/gas',
+		body: {
+			FixedAmountRequest: {
+				recipient: input.recipient,
+			},
+		},
+		headers: input.headers,
+		method: 'POST',
+	});
+
+	if (response.status !== 'Success') {
+		throw new Error(`Faucet request failed: ${response.status.Failure.internal}`);
+	}
+
+	return response;
+}
+
+/**
+ * @deprecated "Use requestHaneulFromFaucetV2 which returns directly a success or failure status"
+ */
+export async function getFaucetRequestStatus(input: {
+	host: string;
+	taskId: string;
+	headers?: HeadersInit;
+}) {
+	const response = await faucetRequest<BatchStatusFaucetResponse>({
+		host: input.host,
+		path: `/v1/status/${input.taskId}`,
+		headers: input.headers,
+		method: 'GET',
+	});
+
+	if (response.error) {
+		throw new Error(`Faucet request failed: ${response.error}`);
+	}
+
+	return response;
+}
+
+export function getFaucetHost(network: 'testnet' | 'devnet' | 'localnet') {
+	switch (network) {
+		case 'testnet':
+			return 'https://faucet.testnet.sui.io';
+		case 'devnet':
+			return 'https://faucet.devnet.sui.io';
+		case 'localnet':
+			return 'http://127.0.0.1:9123';
+		default:
+			throw new Error(`Unknown network: ${network}`);
+	}
+}

package/src/faucet/index.ts

@@ -0,0 +1,11 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export {
+	requestHaneulFromFaucetV0,
+	requestHaneulFromFaucetV1,
+	requestHaneulFromFaucetV2,
+	getFaucetRequestStatus,
+	getFaucetHost,
+	FaucetRateLimitError,
+} from './faucet.js';

package/src/graphql/client.ts

@@ -0,0 +1,134 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { TadaDocumentNode } from 'gql.tada';
+import type { DocumentNode } from 'graphql';
+import { print } from 'graphql';
+import { Experimental_BaseClient } from '../experimental/index.js';
+import type { Experimental_HaneulClientTypes } from '../experimental/index.js';
+import { GraphQLCoreClient } from './core.js';
+import type { TypedDocumentString } from './generated/queries.js';
+
+export type GraphQLDocument<
+	Result = Record<string, unknown>,
+	Variables = Record<string, unknown>,
+> =
+	| string
+	| DocumentNode
+	| TypedDocumentString<Result, Variables>
+	| TypedDocumentNode<Result, Variables>
+	| TadaDocumentNode<Result, Variables>;
+
+export type GraphQLQueryOptions<
+	Result = Record<string, unknown>,
+	Variables = Record<string, unknown>,
+> = {
+	query: GraphQLDocument<Result, Variables>;
+	operationName?: string;
+	extensions?: Record<string, unknown>;
+	signal?: AbortSignal;
+} & (Variables extends { [key: string]: never }
+	? { variables?: Variables }
+	: {
+			variables: Variables;
+		});
+
+export type GraphQLQueryResult<Result = Record<string, unknown>> = {
+	data?: Result;
+	errors?: GraphQLResponseErrors;
+	extensions?: Record<string, unknown>;
+};
+
+export type GraphQLResponseErrors = Array<{
+	message: string;
+	locations?: { line: number; column: number }[];
+	path?: (string | number)[];
+}>;
+
+export interface HaneulGraphQLClientOptions<Queries extends Record<string, GraphQLDocument>> {
+	url: string;
+	fetch?: typeof fetch;
+	headers?: Record<string, string>;
+	queries?: Queries;
+	network?: Experimental_HaneulClientTypes.Network;
+	mvr?: Experimental_HaneulClientTypes.MvrOptions;
+}
+
+export class HaneulGraphQLRequestError extends Error {}
+
+export class HaneulGraphQLClient<
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	Queries extends Record<string, GraphQLDocument> = {},
+> extends Experimental_BaseClient {
+	#url: string;
+	#queries: Queries;
+	#headers: Record<string, string>;
+	#fetch: typeof fetch;
+	core: GraphQLCoreClient;
+
+	constructor({
+		url,
+		fetch: fetchFn = fetch,
+		headers = {},
+		queries = {} as Queries,
+		network = 'unknown',
+		mvr,
+	}: HaneulGraphQLClientOptions<Queries>) {
+		super({
+			network,
+		});
+		this.#url = url;
+		this.#queries = queries;
+		this.#headers = headers;
+		this.#fetch = (...args) => fetchFn(...args);
+		this.core = new GraphQLCoreClient({
+			graphqlClient: this,
+			mvr,
+		});
+	}
+
+	async query<Result = Record<string, unknown>, Variables = Record<string, unknown>>(
+		options: GraphQLQueryOptions<Result, Variables>,
+	): Promise<GraphQLQueryResult<Result>> {
+		const res = await this.#fetch(this.#url, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				...this.#headers,
+			},
+			body: JSON.stringify({
+				query:
+					typeof options.query === 'string' || options.query instanceof String
+						? String(options.query)
+						: print(options.query),
+				variables: options.variables,
+				extensions: options.extensions,
+				operationName: options.operationName,
+			}),
+			signal: options.signal,
+		});
+
+		if (!res.ok) {
+			throw new HaneulGraphQLRequestError(`GraphQL request failed: ${res.statusText} (${res.status})`);
+		}
+
+		return await res.json();
+	}
+
+	async execute<
+		const Query extends Extract<keyof Queries, string>,
+		Result = Queries[Query] extends GraphQLDocument<infer R, unknown> ? R : Record<string, unknown>,
+		Variables = Queries[Query] extends GraphQLDocument<unknown, infer V>
+			? V
+			: Record<string, unknown>,
+	>(
+		query: Query,
+		options: Omit<GraphQLQueryOptions<Result, Variables>, 'query'>,
+	): Promise<GraphQLQueryResult<Result>> {
+		return this.query({
+			...(options as { variables: Record<string, unknown> }),
+			query: this.#queries[query]!,
+		}) as Promise<GraphQLQueryResult<Result>>;
+	}
+}