@radix-effects/gateway 0.1.0

package/dist/index.js

@@ -0,0 +1,771 @@
+import { Config, Data, Effect } from "effect";
+import { GatewayApiClient as GatewayApiClient$1, ResponseError as ResponseError$1 } from "@radixdlt/babylon-gateway-api-sdk";
+import { z } from "zod";
+import { BigNumber } from "bignumber.js";
+
+//#region src/gatewayApiClient.ts
+var AccountLockerNotFoundError = class extends Data.TaggedError("AccountLockerNotFoundError") {};
+var InternalServerError = class extends Data.TaggedError("InternalServerError") {};
+var InvalidRequestError = class extends Data.TaggedError("InvalidRequestError") {};
+var InvalidEntityError = class extends Data.TaggedError("InvalidEntityError") {};
+var EntityNotFoundError = class extends Data.TaggedError("EntityNotFoundError") {};
+var NotSyncedUpError = class extends Data.TaggedError("NotSyncedUpError") {};
+var TransactionNotFoundError = class extends Data.TaggedError("TransactionNotFoundError") {};
+var InvalidTransactionError = class extends Data.TaggedError("InvalidTransactionError") {};
+var ResponseError = class extends Data.TaggedError("ResponseError") {};
+var ErrorResponse = class extends Data.TaggedError("ErrorResponse") {};
+var RateLimitExceededError = class extends Data.TaggedError("RateLimitExceededError") {};
+var UnknownGatewayError = class extends Data.TaggedError("UnknownGatewayError") {};
+var GatewayApiClient = class extends Effect.Service()("GatewayApiClient", { effect: Effect.gen(function* () {
+	const networkId = yield* Config.number("NETWORK_ID").pipe(Config.withDefault(1));
+	const basePath = yield* Config.string("GATEWAY_URL").pipe(Config.withDefault(void 0));
+	const applicationName = yield* Config.string("APPLICATION_NAME").pipe(Config.withDefault("@radix-effects/gateway"));
+	const gatewayApiKey = yield* Config.string("GATEWAY_BASIC_AUTH").pipe(Config.withDefault(void 0));
+	const gatewayApiClient = GatewayApiClient$1.initialize({
+		networkId,
+		basePath,
+		applicationName,
+		headers: gatewayApiKey ? { Authorization: `Basic ${gatewayApiKey}` } : void 0
+	});
+	const wrapMethod = (fn) => {
+		return (...args) => Effect.tryPromise({
+			try: () => fn(...args),
+			catch: (error) => {
+				if (typeof error === "object" && error !== null && "name" in error) {
+					if (error instanceof ResponseError$1) {
+						if (error.errorResponse) {
+							switch (error.errorResponse.details?.type) {
+								case "AccountLockerNotFoundError": return new AccountLockerNotFoundError({
+									...error.errorResponse.details,
+									code: error.errorResponse.code,
+									message: error.message
+								});
+								case "InvalidRequestError": return new InvalidRequestError({
+									...error.errorResponse.details,
+									code: error.errorResponse.code,
+									message: error.message
+								});
+								case "EntityNotFoundError": return new EntityNotFoundError({
+									...error.errorResponse.details,
+									code: error.errorResponse.code,
+									message: error.message
+								});
+								case "InternalServerError": return new InternalServerError({
+									...error.errorResponse.details,
+									code: error.errorResponse.code,
+									message: error.message
+								});
+								case "InvalidEntityError": return new InvalidEntityError({
+									...error.errorResponse.details,
+									code: error.errorResponse.code,
+									message: error.message
+								});
+								case "InvalidTransactionError": return new InvalidTransactionError({
+									...error.errorResponse.details,
+									code: error.errorResponse.code,
+									message: error.message
+								});
+								case "NotSyncedUpError": return new NotSyncedUpError({
+									...error.errorResponse.details,
+									code: error.errorResponse.code,
+									message: error.message
+								});
+								case "TransactionNotFoundError": return new TransactionNotFoundError({
+									...error.errorResponse.details,
+									code: error.errorResponse.code,
+									message: error.message
+								});
+							}
+							return new ErrorResponse(error.errorResponse);
+						}
+						if (error.fetchResponse.status === 429) return new RateLimitExceededError({
+							code: error.fetchResponse.status,
+							message: error.fetchResponse.statusText,
+							retryAfter: Number.parseInt(error.fetchResponse.headers.get("retry-after") ?? "0")
+						});
+						return new ResponseError(error);
+					}
+				}
+				return new UnknownGatewayError({ error });
+			}
+		});
+	};
+	return {
+		state: {
+			getEntityDetailsVaultAggregated: wrapMethod(gatewayApiClient.state.getEntityDetailsVaultAggregated.bind(gatewayApiClient.state)),
+			getValidators: wrapMethod(gatewayApiClient.state.getValidators.bind(gatewayApiClient.state)),
+			innerClient: {
+				stateEntityDetails: wrapMethod(gatewayApiClient.state.innerClient.stateEntityDetails.bind(gatewayApiClient.state.innerClient)),
+				entityFungiblesPage: wrapMethod(gatewayApiClient.state.innerClient.entityFungiblesPage.bind(gatewayApiClient.state.innerClient)),
+				entityNonFungiblesPage: wrapMethod(gatewayApiClient.state.innerClient.entityNonFungiblesPage.bind(gatewayApiClient.state.innerClient)),
+				entityNonFungibleIdsPage: wrapMethod(gatewayApiClient.state.innerClient.entityNonFungibleIdsPage.bind(gatewayApiClient.state.innerClient)),
+				entityNonFungibleResourceVaultPage: wrapMethod(gatewayApiClient.state.innerClient.entityNonFungibleResourceVaultPage.bind(gatewayApiClient.state.innerClient)),
+				keyValueStoreKeys: wrapMethod(gatewayApiClient.state.innerClient.keyValueStoreKeys.bind(gatewayApiClient.state.innerClient)),
+				keyValueStoreData: wrapMethod(gatewayApiClient.state.innerClient.keyValueStoreData.bind(gatewayApiClient.state.innerClient)),
+				nonFungibleData: wrapMethod(gatewayApiClient.state.innerClient.nonFungibleData.bind(gatewayApiClient.state.innerClient)),
+				nonFungibleLocation: wrapMethod(gatewayApiClient.state.innerClient.nonFungibleLocation.bind(gatewayApiClient.state.innerClient)),
+				nonFungibleIds: wrapMethod(gatewayApiClient.state.innerClient.nonFungibleIds.bind(gatewayApiClient.state.innerClient))
+			}
+		},
+		stream: { innerClient: { streamTransactions: wrapMethod(gatewayApiClient.stream.innerClient.streamTransactions.bind(gatewayApiClient.stream.innerClient)) } },
+		transaction: {
+			getCommittedDetails: wrapMethod(gatewayApiClient.transaction.getCommittedDetails.bind(gatewayApiClient.transaction)),
+			innerClient: {
+				transactionSubmit: wrapMethod(gatewayApiClient.transaction.innerClient.transactionSubmit.bind(gatewayApiClient.transaction.innerClient)),
+				transactionStatus: wrapMethod(gatewayApiClient.transaction.innerClient.transactionStatus.bind(gatewayApiClient.transaction.innerClient))
+			}
+		},
+		status: {
+			getCurrent: wrapMethod(gatewayApiClient.status.getCurrent.bind(gatewayApiClient.status)),
+			innerClient: { gatewayStatus: wrapMethod(gatewayApiClient.status.innerClient.gatewayStatus.bind(gatewayApiClient.status.innerClient)) }
+		},
+		extensions: { getResourceHolders: wrapMethod(gatewayApiClient.extensions.getResourceHolders.bind(gatewayApiClient.extensions)) },
+		rawClient: gatewayApiClient
+	};
+}) }) {};
+
+//#endregion
+//#region src/state/entityFungiblesPage.ts
+var EntityFungiblesPage = class extends Effect.Service()("EntityFungiblesPage", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__MaxPageSize").pipe(Config.withDefault(100));
+		const entityFungiblesPage = Effect.fnUntraced(function* (input) {
+			return yield* gatewayClient.state.innerClient.entityFungiblesPage({ stateEntityFungiblesPageRequest: {
+				...input,
+				limit_per_page: pageSize
+			} });
+		});
+		return Effect.fnUntraced(function* (input) {
+			const result = yield* entityFungiblesPage(input);
+			let nextCursor = result?.next_cursor;
+			const items = result?.items ?? [];
+			while (nextCursor) {
+				const result$1 = yield* entityFungiblesPage({
+					...input,
+					cursor: nextCursor
+				});
+				nextCursor = result$1.next_cursor;
+				items.push(...result$1.items);
+			}
+			return items;
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/helpers/chunker.ts
+const chunker = (array, size) => {
+	return array.reduce((acc, item, index) => {
+		const chunkIndex = Math.floor(index / size);
+		if (!acc[chunkIndex]) acc[chunkIndex] = [];
+		acc[chunkIndex].push(item);
+		return acc;
+	}, []);
+};
+
+//#endregion
+//#region src/state/nonFungibleData.ts
+var NonFungibleData = class extends Effect.Service()("NonFungibleData", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__MaxPageSize").pipe(Config.withDefault(100));
+		return Effect.fnUntraced(function* (input) {
+			const chunks = chunker(input.non_fungible_ids, pageSize);
+			return yield* Effect.forEach(chunks, Effect.fnUntraced(function* (chunk) {
+				return yield* gatewayClient.state.innerClient.nonFungibleData({ stateNonFungibleDataRequest: {
+					...input,
+					non_fungible_ids: chunk
+				} });
+			})).pipe(Effect.map((res) => {
+				return res.flatMap((item) => item.non_fungible_ids);
+			}));
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/state/entityNonFungiblesPage.ts
+var EntityNonFungiblesPage = class extends Effect.Service()("EntityNonFungiblesPage", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__MaxPageSize").pipe(Config.withDefault(100));
+		return Effect.fnUntraced(function* (input) {
+			return yield* gatewayClient.state.innerClient.entityNonFungiblesPage({ stateEntityNonFungiblesPageRequest: {
+				...input,
+				limit_per_page: pageSize
+			} });
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/state/getValidators.ts
+const ValidatorSchema = z.object({
+	address: z.string(),
+	name: z.string(),
+	lsuResourceAddress: z.string(),
+	claimNftResourceAddress: z.string()
+});
+var GetValidators = class extends Effect.Service()("GetValidators", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		return Effect.fn(function* () {
+			return (yield* gatewayClient.state.getValidators()).items.map((item) => {
+				const address = item.address;
+				const { name, lsuResourceAddress, claimNftResourceAddress } = item.metadata.items.reduce((acc, curr) => {
+					if (curr.key === "name" && curr.value.typed.type === "String") acc.name = curr.value.typed.value;
+					if (curr.key === "pool_unit" && curr.value.typed.type === "GlobalAddress") acc.lsuResourceAddress = curr.value.typed.value;
+					if (curr.key === "claim_nft" && curr.value.typed.type === "GlobalAddress") acc.claimNftResourceAddress = curr.value.typed.value;
+					return acc;
+				}, {
+					name: "",
+					lsuResourceAddress: "",
+					claimNftResourceAddress: ""
+				});
+				return {
+					address,
+					name,
+					lsuResourceAddress,
+					claimNftResourceAddress
+				};
+			});
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/state/getEntityDetailsVaultAggregated.ts
+var GetEntityDetailsVaultAggregated = class extends Effect.Service()("GetEntityDetailsVaultAggregated", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__StateEntityDetailsPageSize").pipe(Config.withDefault(20));
+		return Effect.fnUntraced(function* (input, options, at_ledger_state) {
+			const chunks = chunker(input, pageSize);
+			return yield* Effect.forEach(chunks, Effect.fn(function* (addresses) {
+				return yield* gatewayClient.state.getEntityDetailsVaultAggregated(addresses, options, at_ledger_state);
+			})).pipe(Effect.map((res) => res.flat()));
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/state/entityNonFungibleIdsPage.ts
+var EntityNonFungibleIdsPage = class extends Effect.Service()("EntityNonFungibleIdsPage", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__StateEntityDetailsPageSize").pipe(Config.withDefault(100));
+		return Effect.fn(function* (input) {
+			const makeRequest = (cursor) => gatewayClient.state.innerClient.entityNonFungibleIdsPage({ stateEntityNonFungibleIdsPageRequest: {
+				resource_address: input.resourceAddress,
+				vault_address: input.vaultAddress,
+				address: input.address,
+				at_ledger_state: input.at_ledger_state,
+				cursor,
+				limit_per_page: pageSize
+			} });
+			const result = yield* makeRequest(input.cursor);
+			let next_cursor = result.next_cursor;
+			const totalCount = result.total_count ?? 0;
+			const ids = [...result.items];
+			while (next_cursor && totalCount > 0) {
+				const result$1 = yield* makeRequest(next_cursor);
+				ids.push(...result$1.items);
+				next_cursor = result$1.next_cursor;
+			}
+			return {
+				ids,
+				address: input.address
+			};
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getNonFungibleLocation.ts
+var GetNonFungibleLocationService = class extends Effect.Service()("GetNonFungibleLocationService", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__MaxPageSize").pipe(Config.withDefault(100));
+		return Effect.fn(function* (input) {
+			const chunks = chunker(input.nonFungibleIds, pageSize);
+			return yield* Effect.forEach(chunks, Effect.fn(function* (nonFungibleIds) {
+				return yield* gatewayClient.state.innerClient.nonFungibleLocation({ stateNonFungibleLocationRequest: {
+					non_fungible_ids: nonFungibleIds,
+					resource_address: input.resourceAddress,
+					at_ledger_state: input.at_ledger_state
+				} });
+			})).pipe(Effect.map((res) => res.flat()));
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getAddressByNonFungible.ts
+var EntityNotFoundError$2 = class extends Data.TaggedError("EntityNotFoundError") {};
+var GetAddressByNonFungibleService = class extends Effect.Service()("GetAddressByNonFungibleService", {
+	dependencies: [GetNonFungibleLocationService.Default],
+	effect: Effect.gen(function* () {
+		const getNonFungibleLocationService = yield* GetNonFungibleLocationService;
+		return Effect.fn(function* (input) {
+			let isBurned = true;
+			let nextStateVersion = input.at_ledger_state;
+			let address = "";
+			while (isBurned) {
+				const firstLocation = (yield* getNonFungibleLocationService({
+					resourceAddress: input.resourceAddress,
+					nonFungibleIds: [input.nonFungibleId],
+					at_ledger_state: nextStateVersion
+				}))[0];
+				if (!firstLocation) return yield* Effect.fail(new EntityNotFoundError$2({ message: `Non-fungible location not found for resource address ${input.resourceAddress} and non-fungible id ${input.nonFungibleId}` }));
+				const result = firstLocation.non_fungible_ids[0];
+				if (!result) return yield* Effect.fail(new EntityNotFoundError$2({ message: `Non-fungible location not found for resource address ${input.resourceAddress} and non-fungible id ${input.nonFungibleId}` }));
+				isBurned = result.is_burned;
+				nextStateVersion = { state_version: firstLocation.ledger_state.state_version - 1 };
+				if (result.owning_vault_global_ancestor_address) address = result.owning_vault_global_ancestor_address;
+			}
+			return {
+				address,
+				resourceAddress: input.resourceAddress,
+				nonFungibleId: input.nonFungibleId
+			};
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getComponentState.ts
+var InvalidComponentStateError = class {
+	constructor(error) {
+		this.error = error;
+		this._tag = "InvalidComponentStateError";
+	}
+};
+var GetComponentStateService = class extends Effect.Service()("GetComponentStateService", {
+	dependencies: [GetEntityDetailsVaultAggregated.Default],
+	effect: Effect.gen(function* () {
+		const getEntityDetails = yield* GetEntityDetailsVaultAggregated;
+		return { run: Effect.fnUntraced(function* (input) {
+			const entityDetails = yield* getEntityDetails(input.addresses, input.options, input.at_ledger_state);
+			const results = [];
+			for (const item of entityDetails) if (item.details?.type === "Component") {
+				const componentState = item.details.state;
+				const parsed = input.schema.safeParse(componentState);
+				if (parsed.isErr()) return yield* Effect.fail(new InvalidComponentStateError(parsed.error));
+				if (parsed.isOk()) results.push({
+					address: item.address,
+					state: parsed.value,
+					details: item
+				});
+			}
+			return results;
+		}) };
+	})
+}) {};
+
+//#endregion
+//#region src/state/stateEntityDetails.ts
+var StateEntityDetails = class extends Effect.Service()("StateEntityDetails", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__StateEntityDetailsPageSize").pipe(Config.withDefault(20));
+		const concurrency = yield* Config.number("GATEWAY_STATE_ENTITY_DETAILS_CONCURRENCY").pipe(Config.withDefault(5));
+		return Effect.fnUntraced(function* (input) {
+			const chunks = chunker(input.addresses, pageSize);
+			return yield* Effect.forEach(chunks, Effect.fnUntraced(function* (addresses) {
+				return yield* gatewayClient.state.innerClient.stateEntityDetails({ stateEntityDetailsRequest: {
+					...input,
+					addresses
+				} });
+			}), { concurrency }).pipe(Effect.map((res) => {
+				return {
+					ledger_state: res[0].ledger_state,
+					items: res.flatMap((item) => item.items)
+				};
+			}));
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getFungibleBalance.ts
+var GetFungibleBalance = class extends Effect.Service()("GetFungibleBalance", {
+	dependencies: [EntityFungiblesPage.Default, StateEntityDetails.Default],
+	effect: Effect.gen(function* () {
+		const stateEntityDetails = yield* StateEntityDetails;
+		const entityFungiblesPage = yield* EntityFungiblesPage;
+		const concurrency = yield* Config.number("GATEWAY_GET_FUNGIBLE_BALANCE_CONCURRENCY").pipe(Config.withDefault(5));
+		const getAggregatedFungibleBalance = Effect.fnUntraced(function* (item, at_ledger_state) {
+			const address = item.address;
+			const nextCursor = item.fungible_resources?.next_cursor;
+			const totalCount = item.fungible_resources?.total_count ?? 0;
+			const allFungibleResources = item.fungible_resources?.items ?? [];
+			if (nextCursor && totalCount > 0) {
+				const result = yield* entityFungiblesPage({
+					address,
+					aggregation_level: "Global",
+					cursor: nextCursor,
+					at_ledger_state
+				});
+				allFungibleResources.push(...result);
+			}
+			const fungibleResources = allFungibleResources.map((item$1) => {
+				if (item$1.aggregation_level === "Global") {
+					const { aggregation_level, amount,...rest } = item$1;
+					return {
+						...rest,
+						amount: new BigNumber(amount)
+					};
+				}
+			}).filter((item$1) => item$1 !== void 0).filter((item$1) => item$1.amount.gt(0));
+			return {
+				address: item.address,
+				items: fungibleResources
+			};
+		});
+		return Effect.fnUntraced(function* (input) {
+			const stateEntityDetailsResults = yield* stateEntityDetails({
+				addresses: input.addresses,
+				opt_ins: input.options,
+				at_ledger_state: input.at_ledger_state,
+				aggregation_level: "Global"
+			});
+			return yield* Effect.forEach(stateEntityDetailsResults.items, (item) => getAggregatedFungibleBalance(item, input.at_ledger_state), { concurrency }).pipe(Effect.map((results) => results.flat()));
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/keyValueStoreData.ts
+var KeyValueStoreDataService = class extends Effect.Service()("KeyValueStoreDataService", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__MaxPageSize").pipe(Config.withDefault(100));
+		return Effect.fn(function* (input) {
+			const chunks = chunker(input.keys, pageSize);
+			return yield* Effect.forEach(chunks, Effect.fn(function* (keys) {
+				return yield* gatewayClient.state.innerClient.keyValueStoreData({ stateKeyValueStoreDataRequest: {
+					keys,
+					at_ledger_state: input.at_ledger_state,
+					key_value_store_address: input.key_value_store_address
+				} });
+			})).pipe(Effect.map((res) => res.flat()));
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/keyValueStoreKeys.ts
+var KeyValueStoreKeysService = class extends Effect.Service()("KeyValueStoreKeysService", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const pageSize = yield* Config.number("GatewayApi__Endpoint__MaxPageSize").pipe(Config.withDefault(100));
+		return Effect.fn(function* (input) {
+			return yield* gatewayClient.state.innerClient.keyValueStoreKeys({ stateKeyValueStoreKeysRequest: {
+				...input,
+				limit_per_page: pageSize
+			} });
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getKeyValueStore.ts
+var GetKeyValueStoreService = class extends Effect.Service()("GetKeyValueStoreService", {
+	dependencies: [KeyValueStoreKeysService.Default, KeyValueStoreDataService.Default],
+	effect: Effect.gen(function* () {
+		const keyValueStoreKeysService = yield* KeyValueStoreKeysService;
+		const keyValueStoreDataService = yield* KeyValueStoreDataService;
+		return Effect.fn(function* (input) {
+			const keyResults = yield* keyValueStoreKeysService({
+				key_value_store_address: input.address,
+				at_ledger_state: input.at_ledger_state
+			});
+			const allKeys = [...keyResults.items];
+			let nextCursor = keyResults.next_cursor;
+			while (nextCursor) {
+				const nextKeyResults = yield* keyValueStoreKeysService({
+					key_value_store_address: input.address,
+					at_ledger_state: input.at_ledger_state,
+					cursor: nextCursor
+				});
+				allKeys.push(...nextKeyResults.items);
+				nextCursor = nextKeyResults.next_cursor;
+			}
+			return yield* keyValueStoreDataService({
+				key_value_store_address: input.address,
+				keys: allKeys.map(({ key }) => ({ key_json: key.programmatic_json })),
+				at_ledger_state: input.at_ledger_state
+			}).pipe(Effect.map((res) => {
+				const { key_value_store_address, ledger_state } = res[0];
+				return {
+					key_value_store_address,
+					ledger_state,
+					entries: res.flatMap((item) => item.entries)
+				};
+			}));
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getLedgerState.ts
+var GetLedgerStateService = class extends Effect.Service()("GetLedgerStateService", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		return Effect.fn("getLedgerStateService")(function* (input) {
+			return (yield* gatewayClient.stream.innerClient.streamTransactions({ streamTransactionsRequest: {
+				limit_per_page: 1,
+				at_ledger_state: input.at_ledger_state
+			} })).ledger_state;
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getNftResourceManagers.ts
+var GetNftResourceManagersService = class extends Effect.Service()("GetNftResourceManagersService", {
+	dependencies: [
+		GatewayApiClient.Default,
+		EntityNonFungiblesPage.Default,
+		EntityNonFungibleIdsPage.Default
+	],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const entityNonFungiblesPageService = yield* EntityNonFungiblesPage;
+		const entityNonFungibleIdsPage = yield* EntityNonFungibleIdsPage;
+		const getNftResourceManagersConcurrency = yield* Config.number("GET_NFT_RESOURCE_MANAGERS_CONCURRENCY").pipe(Config.withDefault(10));
+		const stateEntityDetailsPageSize = yield* Config.number("GatewayApi__Endpoint__StateEntityDetailsPageSize").pipe(Config.withDefault(20));
+		const stateEntityDetailsConcurrency = yield* Config.number("GATEWAY_STATE_ENTITY_DETAILS_CONCURRENCY").pipe(Config.withDefault(10));
+		const getNftIdsConcurrency = yield* Config.number("GET_NFT_IDS_CONCURRENCY").pipe(Config.withDefault(20));
+		const AGGREGATION_LEVEL = "Vault";
+		const getNonFungibleResourceVaultPage = ({ address, cursor, resourceAddress: resource_address, optIns, at_ledger_state }) => gatewayClient.state.innerClient.entityNonFungibleResourceVaultPage({ stateEntityNonFungibleResourceVaultsPageRequest: {
+			address,
+			opt_ins: optIns,
+			at_ledger_state,
+			cursor,
+			resource_address
+		} });
+		const getNftIds = Effect.fn(function* ({ resourceManager, optIns, at_ledger_state, address }) {
+			const vaults = [...resourceManager.vaults.items];
+			let next_cursor = resourceManager.vaults.next_cursor;
+			const totalCount = resourceManager.vaults.total_count ?? 0;
+			while (next_cursor && totalCount > 0) {
+				const vaultsPage = yield* getNonFungibleResourceVaultPage({
+					address,
+					cursor: next_cursor,
+					resourceAddress: resourceManager.resource_address,
+					optIns,
+					at_ledger_state
+				});
+				vaults.push(...vaultsPage.items);
+				next_cursor = vaultsPage.next_cursor;
+			}
+			const nftIds = yield* Effect.forEach(vaults, Effect.fnUntraced(function* (vault) {
+				const nftIds$1 = vault?.items || [];
+				if (vault.next_cursor && vault.total_count > 0) {
+					const { ids } = yield* entityNonFungibleIdsPage({
+						vaultAddress: vault.vault_address,
+						resourceAddress: resourceManager.resource_address,
+						at_ledger_state,
+						address,
+						cursor: vault.next_cursor
+					});
+					nftIds$1.push(...ids);
+				}
+				return nftIds$1;
+			})).pipe(Effect.map((ids) => ids.flat()));
+			return {
+				resourceAddress: resourceManager.resource_address,
+				nftIds
+			};
+		});
+		const getStateEntityDetails = Effect.fn("getStateEntityDetails")(function* (input) {
+			const { addresses, optIns, at_ledger_state } = input;
+			return yield* Effect.forEach(chunker(addresses, stateEntityDetailsPageSize), Effect.fnUntraced(function* (addresses$1) {
+				return yield* gatewayClient.state.innerClient.stateEntityDetails({ stateEntityDetailsRequest: {
+					addresses: addresses$1,
+					opt_ins: optIns,
+					at_ledger_state,
+					aggregation_level: AGGREGATION_LEVEL
+				} });
+			}), { concurrency: stateEntityDetailsConcurrency });
+		});
+		const getResourceManagers = Effect.fn(function* (input) {
+			const { items, aggregationLevel, optIns, filterResourceAddresses } = input;
+			return yield* Effect.forEach(items, Effect.fnUntraced(function* (item) {
+				const resourceManagers = item.non_fungible_resources?.items ?? [];
+				const address = item.address;
+				let next_cursor = item.non_fungible_resources?.next_cursor;
+				const totalCount = item.non_fungible_resources?.total_count ?? 0;
+				while (next_cursor && totalCount > 0) {
+					const entityNonFungiblesPageResult = yield* entityNonFungiblesPageService({
+						address,
+						at_ledger_state: input.at_ledger_state,
+						aggregation_level: aggregationLevel,
+						opt_ins: optIns,
+						cursor: next_cursor
+					});
+					resourceManagers.push(...entityNonFungiblesPageResult.items);
+					next_cursor = entityNonFungiblesPageResult.next_cursor;
+				}
+				return {
+					address,
+					resourceManagers: filterResourceAddresses ? resourceManagers.filter((resourceManager) => filterResourceAddresses.includes(resourceManager.resource_address)) : resourceManagers
+				};
+			}));
+		});
+		return Effect.fn("getNftResourceManagersService")(function* (input) {
+			const optIns = {
+				...input.options,
+				non_fungible_include_nfids: true
+			};
+			const filterResourceAddresses = input.resourceAddresses;
+			const stateEntityDetailsResults = yield* getStateEntityDetails({
+				addresses: input.addresses,
+				optIns,
+				at_ledger_state: input.at_ledger_state
+			});
+			const resourceManagerResults = yield* Effect.forEach(stateEntityDetailsResults, Effect.fnUntraced(function* (stateEntityDetails) {
+				return yield* getResourceManagers({
+					items: stateEntityDetails.items,
+					at_ledger_state: input.at_ledger_state,
+					aggregationLevel: AGGREGATION_LEVEL,
+					optIns,
+					filterResourceAddresses
+				});
+			}), { concurrency: getNftResourceManagersConcurrency }).pipe(Effect.map((items) => items.flat()));
+			return yield* Effect.forEach(resourceManagerResults, Effect.fnUntraced(function* (resourceManagerResult) {
+				const nftIds = yield* Effect.forEach(resourceManagerResult.resourceManagers, (resourceManager) => getNftIds({
+					resourceManager,
+					optIns,
+					at_ledger_state: input.at_ledger_state,
+					address: resourceManagerResult.address
+				}));
+				return {
+					address: resourceManagerResult.address,
+					items: nftIds
+				};
+			}), { concurrency: getNftIdsConcurrency });
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getNonFungibleBalance.ts
+var InvalidInputError = class {
+	constructor(error) {
+		this.error = error;
+		this._tag = "InvalidInputError";
+	}
+};
+var GetNonFungibleBalanceService = class extends Effect.Service()("GetNonFungibleBalanceService", {
+	dependencies: [NonFungibleData.Default, GetNftResourceManagersService.Default],
+	effect: Effect.gen(function* () {
+		const entityNonFungibleDataService = yield* NonFungibleData;
+		const getNftResourceManagersService = yield* GetNftResourceManagersService;
+		const getNonFungibleDataConcurrency = yield* Config.number("GATEWAY_GET_NON_FUNGIBLE_DATA_CONCURRENCY").pipe(Config.withDefault(15));
+		const getNonFungibleData = Effect.fn(function* (input) {
+			return yield* Effect.forEach(input.items, Effect.fn(function* (item) {
+				if (item.nftIds.length === 0) return yield* Effect.succeed({
+					resourceAddress: item.resourceAddress,
+					items: []
+				});
+				const items = (yield* entityNonFungibleDataService({
+					resource_address: item.resourceAddress,
+					non_fungible_ids: item.nftIds,
+					at_ledger_state: input.at_ledger_state
+				})).map((nftDataItem) => ({
+					id: nftDataItem.non_fungible_id,
+					lastUpdatedStateVersion: nftDataItem.last_updated_at_state_version,
+					sbor: nftDataItem.data?.programmatic_json,
+					isBurned: nftDataItem.is_burned
+				}));
+				return {
+					resourceAddress: item.resourceAddress,
+					items
+				};
+			}));
+		});
+		return Effect.fn("getNonFungibleBalanceService")(function* (input) {
+			const optIns = {
+				...input.options,
+				non_fungible_include_nfids: true
+			};
+			const accountNonFungibleBalances = yield* getNftResourceManagersService({
+				addresses: input.addresses,
+				at_ledger_state: input.at_ledger_state,
+				resourceAddresses: input.resourceAddresses,
+				options: optIns
+			});
+			return { items: yield* Effect.forEach(accountNonFungibleBalances, Effect.fn(function* ({ address, items }) {
+				return {
+					address,
+					nonFungibleResources: yield* getNonFungibleData({
+						items,
+						at_ledger_state: input.at_ledger_state
+					})
+				};
+			}), { concurrency: getNonFungibleDataConcurrency }).pipe(Effect.withSpan("get non-fungible data for each account")) };
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/getResourceHolders.ts
+var GetResourceHoldersService = class extends Effect.Service()("GetResourceHoldersService", {
+	dependencies: [GatewayApiClient.Default],
+	effect: Effect.gen(function* () {
+		const gatewayClient = yield* GatewayApiClient;
+		const getResourceHolders = Effect.fn(function* (input) {
+			return yield* gatewayClient.extensions.getResourceHolders(input.resourceAddress, input.cursor);
+		});
+		return Effect.fn(function* (input) {
+			const result = yield* getResourceHolders(input);
+			const allItems = [...result.items];
+			let nextCursor = result.next_cursor;
+			while (nextCursor) {
+				const nextResult = yield* getResourceHolders({
+					resourceAddress: input.resourceAddress,
+					cursor: nextCursor
+				});
+				allItems.push(...nextResult.items);
+				nextCursor = nextResult.next_cursor;
+			}
+			const holders = /* @__PURE__ */ new Map();
+			for (const item of allItems) holders.set(item.holder_address, item);
+			return Array.from(holders.values());
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/schemas.ts
+const StateVersionSchema = z.object({ state_version: z.number() });
+const TimestampSchema = z.object({ timestamp: z.date() });
+const AtLedgerStateSchema = z.union([StateVersionSchema, TimestampSchema]);
+var InvalidStateInputError = class {
+	constructor(error) {
+		this.error = error;
+		this._tag = "InvalidStateInputError";
+	}
+};
+const validateAtLedgerStateInput = (input) => Effect.gen(function* () {
+	const parsed = AtLedgerStateSchema.safeParse(input);
+	if (!parsed.success) return yield* Effect.fail(new InvalidStateInputError(parsed.error));
+	return parsed.data;
+});
+
+//#endregion
+export { AccountLockerNotFoundError, AtLedgerStateSchema, EntityFungiblesPage, EntityNonFungibleIdsPage, EntityNonFungiblesPage, EntityNotFoundError, ErrorResponse, GatewayApiClient, GetAddressByNonFungibleService, GetComponentStateService, GetEntityDetailsVaultAggregated, GetFungibleBalance, GetKeyValueStoreService, GetLedgerStateService, GetNftResourceManagersService, GetNonFungibleBalanceService, GetNonFungibleLocationService, GetResourceHoldersService, GetValidators, InternalServerError, InvalidComponentStateError, InvalidEntityError, InvalidInputError, InvalidRequestError, InvalidStateInputError, InvalidTransactionError, KeyValueStoreDataService, KeyValueStoreKeysService, NonFungibleData, NotSyncedUpError, RateLimitExceededError, ResponseError, StateVersionSchema, TimestampSchema, TransactionNotFoundError, UnknownGatewayError, ValidatorSchema, validateAtLedgerStateInput };