@herd-labs/sdk 0.3.0 → 0.4.0

package/dist/src/live/CodeBlocksServiceLive.js

@@ -3,16 +3,20 @@ import { CodeBlockExecuteResponse, CodeBlocksSearchResponse, CreateCodeBlockResp
 import { CodeBlocksService } from "../services/CodeBlocksService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Array, Effect, Layer, Option, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/CodeBlocksServiceLive.ts
-const mapNotFound = (id) => Effect.catchAll((error) => {
+const mapNotFound = (id) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new CodeBlockNotFoundError({ id }));
 	return Effect.fail(error);
 });
 const CodeBlocksServiceLive = Layer.effect(CodeBlocksService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to create code block"))),
+		createCode: (definitionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeVersionResponse)), Effect.mapError(ensureServiceError("Failed to create code version")), mapNotFound(definitionId)),
+		delete: (definitionId) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete code block")), mapNotFound(definitionId)),
+		execute: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/execute`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlockExecuteResponse)), Effect.mapError(ensureServiceError("Failed to execute code block")), mapNotFound(definitionId)),
 		get: (id) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody({
 			scope: "user",
 			limit: 1,
@@ -21,14 +25,10 @@ const CodeBlocksServiceLive = Layer.effect(CodeBlocksService, Effect.gen(functio
 			onNone: () => Effect.fail(new CodeBlockNotFoundError({ id })),
 			onSome: Effect.succeed
 		})))),
+		publishCode: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/publish`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to publish code block")), mapNotFound(definitionId)),
 		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponse)), Effect.mapError(ensureServiceError("Failed to search code blocks"))),
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to create code block"))),
-		updateMetadata: (definitionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code block metadata")), mapNotFound(definitionId)),
-		createCode: (definitionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeVersionResponse)), Effect.mapError(ensureServiceError("Failed to create code version")), mapNotFound(definitionId)),
 		updateCode: (definitionId, codeId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code")), mapNotFound(definitionId)),
-		publishCode: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/publish`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to publish code block")), mapNotFound(definitionId)),
-		execute: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/execute`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlockExecuteResponse)), Effect.mapError(ensureServiceError("Failed to execute code block")), mapNotFound(definitionId)),
-		delete: (definitionId) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete code block")), mapNotFound(definitionId))
+		updateMetadata: (definitionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code block metadata")), mapNotFound(definitionId))
 	};
 }));
 

package/dist/src/live/CollectionsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { CollectionsService } from "../services/CollectionsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient13 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient9 from "effect/unstable/http/HttpClient";
 
 //#region src/live/CollectionsServiceLive.d.ts
-declare const CollectionsServiceLive: Layer.Layer<CollectionsService, never, HerdConfig | _effect_platform_HttpClient13.HttpClient>;
+declare const CollectionsServiceLive: Layer.Layer<CollectionsService, never, HerdConfig | effect_unstable_http_HttpClient9.HttpClient>;
 //#endregion
 export { CollectionsServiceLive };

package/dist/src/live/CollectionsServiceLive.js

@@ -3,19 +3,19 @@ import { Collection, CollectionsSearchResponse, CreateCollectionResponse } from
 import { CollectionsService } from "../services/CollectionsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/CollectionsServiceLive.ts
-const mapNotFound = (id) => Effect.catchAll((error) => {
+const mapNotFound = (id) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new CollectionNotFoundError({ id }));
 	return Effect.fail(error);
 });
 const CollectionsServiceLive = Layer.effect(CollectionsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCollectionResponse)), Effect.mapError(ensureServiceError("Failed to create collection"))),
 		get: (collectionId) => pipe(client.get(makeUrl(baseUrl, `/v1/collections/${collectionId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Collection)), Effect.mapError(ensureServiceError("Failed to get collection")), mapNotFound(collectionId)),
 		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionsSearchResponse)), Effect.mapError(ensureServiceError("Failed to search collections"))),
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCollectionResponse)), Effect.mapError(ensureServiceError("Failed to create collection"))),
 		update: (collectionId, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/collections/${collectionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update collection")), mapNotFound(collectionId))
 	};
 }));

package/dist/src/live/ContractsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { ContractsService } from "../services/ContractsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient9 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient7 from "effect/unstable/http/HttpClient";
 
 //#region src/live/ContractsServiceLive.d.ts
-declare const ContractsServiceLive: Layer.Layer<ContractsService, never, HerdConfig | _effect_platform_HttpClient9.HttpClient>;
+declare const ContractsServiceLive: Layer.Layer<ContractsService, never, HerdConfig | effect_unstable_http_HttpClient7.HttpClient>;
 //#endregion
 export { ContractsServiceLive };

package/dist/src/live/ContractsServiceLive.js

@@ -4,16 +4,12 @@ import { DeployedContracts } from "../schemas/wallets.js";
 import { ContractsService } from "../services/ContractsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/ContractsServiceLive.ts
 const ContractsServiceLive = Layer.effect(ContractsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		getMetadata: (address, blockchain) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/metadata_enriched"), { body: jsonBody({
-			contractAddress: address,
-			blockchain
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractMetadata)), Effect.mapError(ensureServiceError("Failed to get contract metadata"))),
 		diffVersions: (address, blockchain, params) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/diff_versions"), { body: jsonBody({
 			contractAddress: address,
 			blockchain,
@@ -23,7 +19,11 @@ const ContractsServiceLive = Layer.effect(ContractsService, Effect.gen(function*
 			blockchain,
 			...params
 		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GetContractCodeResponse)), Effect.mapError(ensureServiceError("Failed to get contract code"))),
-		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, params)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts")))
+		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, params)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
+		getMetadata: (address, blockchain) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/metadata_enriched"), { body: jsonBody({
+			contractAddress: address,
+			blockchain
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractMetadata)), Effect.mapError(ensureServiceError("Failed to get contract metadata")))
 	};
 }));
 

package/dist/src/live/DocsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { DocsService } from "../services/DocsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient12 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient11 from "effect/unstable/http/HttpClient";
 
 //#region src/live/DocsServiceLive.d.ts
-declare const DocsServiceLive: Layer.Layer<DocsService, never, HerdConfig | _effect_platform_HttpClient12.HttpClient>;
+declare const DocsServiceLive: Layer.Layer<DocsService, never, HerdConfig | effect_unstable_http_HttpClient11.HttpClient>;
 //#endregion
 export { DocsServiceLive };

package/dist/src/live/DocsServiceLive.js

@@ -3,13 +3,13 @@ import { DocContent, DocEntry } from "../schemas/docs.js";
 import { DocsService } from "../services/DocsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
 import { Effect, Layer, Schema, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/DocsServiceLive.ts
 const DocsServiceLive = Layer.effect(DocsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		list: () => pipe(client.get(makeUrl(baseUrl, "/v1/docs")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(DocEntry))), Effect.mapError(ensureServiceError("Failed to list docs"))),
+		list: pipe(client.get(makeUrl(baseUrl, "/v1/docs")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(DocEntry))), Effect.mapError(ensureServiceError("Failed to list docs"))),
 		read: (docId) => Effect.gen(function* () {
 			const response = yield* pipe(client.get(makeUrl(baseUrl, `/v1/docs/${encodeURIComponent(docId)}`)), Effect.flatMap(checkStatus), Effect.mapError((error) => {
 				const wrapped = ensureServiceError("Failed to read doc")(error);

package/dist/src/live/GroupsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { GroupsService } from "../services/GroupsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient10 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient12 from "effect/unstable/http/HttpClient";
 
 //#region src/live/GroupsServiceLive.d.ts
-declare const GroupsServiceLive: Layer.Layer<GroupsService, never, HerdConfig | _effect_platform_HttpClient10.HttpClient>;
+declare const GroupsServiceLive: Layer.Layer<GroupsService, never, HerdConfig | effect_unstable_http_HttpClient12.HttpClient>;
 //#endregion
 export { GroupsServiceLive };

package/dist/src/live/GroupsServiceLive.js

@@ -3,10 +3,10 @@ import { CreateGroupResponse, EditGroupMetadataResponse, GroupDetails, ListGroup
 import { GroupNotFoundError, GroupsService } from "../services/GroupsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/GroupsServiceLive.ts
-const mapNotFound = (groupId) => Effect.catchAll((error) => {
+const mapNotFound = (groupId) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new GroupNotFoundError(groupId));
 	return Effect.fail(error);
 });
@@ -14,11 +14,11 @@ const GroupsServiceLive = Layer.effect(GroupsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
 		create: ({ params }) => pipe(client.post(makeUrl(baseUrl, "/v1/groups"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateGroupResponse)), Effect.mapError(ensureServiceError("Failed to create group"))),
-		list: () => pipe(client.get(makeUrl(baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponse)), Effect.mapError(ensureServiceError("Failed to list groups"))),
+		editMetadata: ({ groupId, params }) => pipe(client.patch(makeUrl(baseUrl, `/v1/groups/${groupId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EditGroupMetadataResponse)), Effect.mapError(ensureServiceError("Failed to edit group metadata")), mapNotFound(groupId)),
 		get: ({ groupId }) => pipe(client.get(makeUrl(baseUrl, `/v1/groups/${groupId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GroupDetails)), Effect.mapError(ensureServiceError("Failed to get group")), mapNotFound(groupId)),
+		list: pipe(client.get(makeUrl(baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponse)), Effect.mapError(ensureServiceError("Failed to list groups"))),
 		proposeMemberChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/member`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose member change")), mapNotFound(groupId)),
-		proposeQuorumChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/quorum`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose quorum change")), mapNotFound(groupId)),
-		editMetadata: ({ groupId, params }) => pipe(client.patch(makeUrl(baseUrl, `/v1/groups/${groupId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EditGroupMetadataResponse)), Effect.mapError(ensureServiceError("Failed to edit group metadata")), mapNotFound(groupId))
+		proposeQuorumChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/quorum`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose quorum change")), mapNotFound(groupId))
 	};
 }));
 

package/dist/src/live/HalServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { HalService } from "../services/HalService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient6 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient13 from "effect/unstable/http/HttpClient";
 
 //#region src/live/HalServiceLive.d.ts
-declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfig | _effect_platform_HttpClient6.HttpClient>;
+declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfig | effect_unstable_http_HttpClient13.HttpClient>;
 //#endregion
 export { HalServiceLive };

package/dist/src/live/HalServiceLive.js

@@ -3,13 +3,13 @@ import { EvaluateExistingResponse, EvaluateResponse } from "../schemas/hal.js";
 import { HalService } from "../services/HalService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/HalServiceLive.ts
-const mapSimulationError = Effect.catchAll((error) => {
+const mapSimulationError = Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 400) return Effect.fail(new SimulationError({
-		name: "SimulationError",
-		message: String(error.metadata["body"])
+		message: String(error.metadata["body"]),
+		name: "SimulationError"
 	}));
 	return Effect.fail(error);
 });
@@ -21,19 +21,19 @@ const HalServiceLive = Layer.effect(HalService, Effect.gen(function* () {
 		evaluate: (params) => callEvaluate({
 			expression: params.expression,
 			inputValues: params.inputValues ?? {},
-			walletAddress: params.walletAddress,
 			simulationBalanceFunding: params.simulationBalanceFunding ?? [],
+			simulationBlockNumber: params.simulationBlockNumber,
 			tevmForkId: params.tevmForkId,
-			simulationBlockNumber: params.simulationBlockNumber
+			walletAddress: params.walletAddress
 		}),
 		evaluateExisting: (params) => callEvaluateExisting({
-			actionId: params.actionId,
 			actionExpressionId: params.actionExpressionId,
-			walletAddress: params.walletAddress,
+			actionId: params.actionId,
 			inputValues: params.inputValues ?? {},
 			simulationBalanceFunding: params.simulationBalanceFunding ?? [],
+			simulationBlockNumber: params.simulationBlockNumber,
 			tevmForkId: params.tevmForkId,
-			simulationBlockNumber: params.simulationBlockNumber
+			walletAddress: params.walletAddress
 		})
 	};
 }));

package/dist/src/live/TransactionsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { TransactionsService } from "../services/TransactionsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient7 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient4 from "effect/unstable/http/HttpClient";
 
 //#region src/live/TransactionsServiceLive.d.ts
-declare const TransactionsServiceLive: Layer.Layer<TransactionsService, never, HerdConfig | _effect_platform_HttpClient7.HttpClient>;
+declare const TransactionsServiceLive: Layer.Layer<TransactionsService, never, HerdConfig | effect_unstable_http_HttpClient4.HttpClient>;
 //#endregion
 export { TransactionsServiceLive };

package/dist/src/live/TransactionsServiceLive.js

@@ -2,44 +2,44 @@ import { ensureServiceError } from "../errors.js";
 import { LatestEventTransactions, LatestFunctionTransactions, TransactionQueryResponse } from "../schemas/transactions.js";
 import { TransactionsService } from "../services/TransactionsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
-import { Effect, Function, Layer, Option, Record, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { Effect, Layer, Option, Record, pipe } from "effect";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/TransactionsServiceLive.ts
-const toOptionalQuery = (input) => pipe(input, Record.filterMap(Option.liftNullable((v) => v)));
-const latestTxParamsToSnakeCaseQuery = (params) => pipe({
+const toOptionalQuery = (input) => Record.getSomes(Record.map(input, Option.fromNullishOr));
+const latestTxParamsToSnakeCaseQuery = (params) => Record.getSomes(Record.map({
+	after_blocknumber: params?.afterBlocknumber,
+	after_timestamp: params?.afterTimestamp,
+	before_blocknumber: params?.beforeBlocknumber,
+	before_timestamp: params?.beforeTimestamp,
+	called_by: params?.calledBy,
+	direction: params?.direction,
 	limit: params?.limit,
 	offset: params?.offset,
 	page: params?.page,
-	before_timestamp: params?.beforeTimestamp,
-	after_timestamp: params?.afterTimestamp,
-	before_blocknumber: params?.beforeBlocknumber,
-	after_blocknumber: params?.afterBlocknumber,
 	success_only: params?.successOnly === true ? true : void 0,
-	direction: params?.direction,
 	topic1: params?.topic1,
 	topic2: params?.topic2,
-	topic3: params?.topic3,
-	called_by: params?.calledBy
-}, Record.filterMap(Option.liftNullable(Function.identity)));
+	topic3: params?.topic3
+}, Option.fromNullishOr));
 const TransactionsServiceLive = Layer.effect(TransactionsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		getTransaction: (blockchain, txHash) => pipe(client.get(makeUrl(baseUrl, `/v1/transactions/${blockchain}/${txHash}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionQueryResponse)), Effect.mapError(ensureServiceError("Failed to get transaction"))),
-		getLatestFunctionTransactions: (blockchain, address, filter, params) => pipe(client.get(makeUrl(baseUrl, `/v1/contracts/${blockchain}/${address}/latest_function_transactions`, {
+		getLatestEventTransactions: (blockchain, address, filter, params) => pipe(client.get(makeUrl(baseUrl, `/v1/contracts/${blockchain}/${address}/latest_event_transactions`, {
 			...latestTxParamsToSnakeCaseQuery(params),
 			...toOptionalQuery({
 				name: filter.name,
 				signature: filter.signature
 			})
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestFunctionTransactions)), Effect.mapError(ensureServiceError("Failed to get latest function transactions"))),
-		getLatestEventTransactions: (blockchain, address, filter, params) => pipe(client.get(makeUrl(baseUrl, `/v1/contracts/${blockchain}/${address}/latest_event_transactions`, {
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestEventTransactions)), Effect.mapError(ensureServiceError("Failed to get latest event transactions"))),
+		getLatestFunctionTransactions: (blockchain, address, filter, params) => pipe(client.get(makeUrl(baseUrl, `/v1/contracts/${blockchain}/${address}/latest_function_transactions`, {
 			...latestTxParamsToSnakeCaseQuery(params),
 			...toOptionalQuery({
 				name: filter.name,
 				signature: filter.signature
 			})
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestEventTransactions)), Effect.mapError(ensureServiceError("Failed to get latest event transactions")))
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestFunctionTransactions)), Effect.mapError(ensureServiceError("Failed to get latest function transactions"))),
+		getTransaction: (blockchain, txHash) => pipe(client.get(makeUrl(baseUrl, `/v1/transactions/${blockchain}/${txHash}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionQueryResponse)), Effect.mapError(ensureServiceError("Failed to get transaction")))
 	};
 }));
 

package/dist/src/live/WalletsServiceLive.d.ts

@@ -1,9 +1,9 @@
 import { HerdConfig } from "../config.js";
 import { WalletsService } from "../services/WalletsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient8 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient5 from "effect/unstable/http/HttpClient";
 
 //#region src/live/WalletsServiceLive.d.ts
-declare const WalletsServiceLive: Layer.Layer<WalletsService, never, HerdConfig | _effect_platform_HttpClient8.HttpClient>;
+declare const WalletsServiceLive: Layer.Layer<WalletsService, never, HerdConfig | effect_unstable_http_HttpClient5.HttpClient>;
 //#endregion
 export { WalletsServiceLive };

package/dist/src/live/WalletsServiceLive.js

@@ -2,13 +2,20 @@ import { ensureServiceError } from "../errors.js";
 import { DeployedContracts, TokenActivity, TransactionActivity, WalletOverview } from "../schemas/wallets.js";
 import { WalletsService } from "../services/WalletsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
-import { Effect, Function, Layer, Option, Record, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { Effect, Layer, Option, Record, pipe } from "effect";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/WalletsServiceLive.ts
 const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
+		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, {
+			page: params?.page,
+			before_timestamp: params?.beforeTimestamp,
+			after_timestamp: params?.afterTimestamp,
+			before_blocknumber: params?.beforeBlocknumber,
+			after_blocknumber: params?.afterBlocknumber
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
 		getOverview: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/overview`, {
 			before_timestamp: params?.beforeTimestamp,
 			after_timestamp: params?.afterTimestamp,
@@ -25,28 +32,21 @@ const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* ()
 			to_address: params?.toAddress
 		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenActivity)), Effect.mapError(ensureServiceError("Failed to get token activity"))),
 		getTransactions: (query) => {
-			const optionalFields = pipe({
+			const optionalFields = Record.getSomes(Record.map({
 				from_address: query.fromAddress,
 				to_addresses: query.toAddresses,
-				before_timestamp: query.beforeBlocknumber !== void 0 ? void 0 : query.beforeTimestamp,
-				after_timestamp: query.afterBlocknumber !== void 0 ? void 0 : query.afterTimestamp,
+				before_timestamp: query.beforeBlocknumber === void 0 ? query.beforeTimestamp : void 0,
+				after_timestamp: query.afterBlocknumber === void 0 ? query.afterTimestamp : void 0,
 				before_blocknumber: query.beforeBlocknumber,
 				after_blocknumber: query.afterBlocknumber,
 				success_only: query.successOnly === true ? true : void 0
-			}, Record.filterMap(Option.liftNullable(Function.identity)));
+			}, Option.fromNullishOr));
 			return pipe(client.post(makeUrl(baseUrl, "/v1/wallets/transaction-activity"), { body: jsonBody({
 				blockchain: query.blockchain,
 				page: query.page ?? 1,
 				...optionalFields
 			}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionActivity)), Effect.mapError(ensureServiceError("Failed to get wallet transactions")));
-		},
-		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, {
-			page: params?.page,
-			before_timestamp: params?.beforeTimestamp,
-			after_timestamp: params?.afterTimestamp,
-			before_blocknumber: params?.beforeBlocknumber,
-			after_blocknumber: params?.afterBlocknumber
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts")))
+		}
 	};
 }));
 

package/dist/src/live/http.d.ts

@@ -1,17 +1,18 @@
 import { HerdConfig } from "../config.js";
 import { ServiceError } from "../errors.js";
 import { Effect, Schema } from "effect";
-import { HttpBody, HttpClient, HttpClientResponse } from "@effect/platform";
-import * as _effect_platform_HttpClientError0 from "@effect/platform/HttpClientError";
+import { HttpBody, HttpClient, HttpClientResponse, UrlParams } from "effect/unstable/http";
+import * as effect_unstable_http_HttpClientError0 from "effect/unstable/http/HttpClientError";
 
 //#region src/live/http.d.ts
 declare const makeUrl: (baseUrl: string, path: string, queryParams?: object) => string;
 declare const authorizedClient: Effect.Effect<{
   baseUrl: string;
-  client: HttpClient.HttpClient.With<_effect_platform_HttpClientError0.HttpClientError, never>;
+  client: HttpClient.HttpClient.With<effect_unstable_http_HttpClientError0.HttpClientError, never>;
 }, never, HerdConfig | HttpClient.HttpClient>;
-declare const handleJsonResponse: <A, I, R>(schema: Schema.Schema<A, I, R>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<A, ServiceError, R>;
+declare const handleJsonResponse: <S extends Schema.Top>(schema: S) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<S["Type"], ServiceError, S["DecodingServices"]>;
 declare const checkStatus: (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<HttpClientResponse.HttpClientResponse, ServiceError>;
 declare const jsonBody: (body: unknown) => HttpBody.HttpBody;
+declare const urlEncodedBody: (body: UrlParams.Input) => HttpBody.HttpBody;
 //#endregion
-export { authorizedClient, checkStatus, handleJsonResponse, jsonBody, makeUrl };
+export { authorizedClient, checkStatus, handleJsonResponse, jsonBody, makeUrl, urlEncodedBody };

package/dist/src/live/http.js

@@ -1,7 +1,7 @@
 import { HerdConfig } from "../config.js";
 import { ServiceError } from "../errors.js";
-import { Effect, Either, pipe } from "effect";
-import { HttpBody, HttpClient, HttpClientRequest, HttpClientResponse } from "@effect/platform";
+import { Effect, Function, Result, pipe } from "effect";
+import { HttpBody, HttpClient, HttpClientRequest, HttpClientResponse, UrlParams } from "effect/unstable/http";
 
 //#region src/live/http.ts
 const makeUrl = (baseUrl, path, queryParams) => {
@@ -15,22 +15,19 @@ const makeUrl = (baseUrl, path, queryParams) => {
 const authorizedClient = Effect.gen(function* () {
 	const config = yield* HerdConfig;
 	const client = yield* HttpClient.HttpClient;
-	const { baseUrl, authHeaders } = Either.match(config, {
-		onLeft: ({ baseUrl: baseUrl$1, oauthAccessToken }) => ({
-			baseUrl: baseUrl$1,
-			authHeaders: { Authorization: `Bearer ${oauthAccessToken}` }
+	const { baseUrl, authHeaders } = Result.match(config, {
+		onFailure: ({ baseUrl: innerBaseUrl, oauthAccessToken }) => ({
+			authHeaders: { Authorization: `Bearer ${oauthAccessToken}` },
+			baseUrl: innerBaseUrl
 		}),
-		onRight: ({ baseUrl: baseUrl$1, apiKey }) => ({
-			baseUrl: baseUrl$1,
-			authHeaders: { "x-api-key": apiKey }
+		onSuccess: ({ baseUrl: innerBaseUrl, apiKey }) => ({
+			authHeaders: { "x-api-key": apiKey },
+			baseUrl: innerBaseUrl
 		})
 	});
 	return {
 		baseUrl,
-		client: client.pipe(HttpClient.mapRequest(HttpClientRequest.setHeaders({
-			...authHeaders,
-			"Content-Type": "application/json"
-		})))
+		client: client.pipe(HttpClient.mapRequest(HttpClientRequest.setHeaders(authHeaders)))
 	};
 });
 const handleJsonResponse = (schema) => (response) => pipe(HttpClientResponse.schemaBodyJson(schema)(response), Effect.mapError((error) => new ServiceError({
@@ -48,18 +45,19 @@ const extractErrorMessage = (body) => {
 };
 const checkStatus = (response) => {
 	if (response.status >= 200 && response.status < 300) return Effect.succeed(response);
-	return pipe(response.json, Effect.orElse(() => response.text.pipe(Effect.map((text) => text))), Effect.orElseSucceed(() => null), Effect.flatMap((body) => {
+	return pipe(response.json, Effect.catch(() => response.text.pipe(Effect.map((text) => text))), Effect.orElseSucceed(Function.constNull), Effect.flatMap((body) => {
 		const message = extractErrorMessage(body) ?? `HTTP ${String(response.status)} error`;
 		return Effect.fail(new ServiceError({
 			message,
 			metadata: {
-				status: response.status,
-				body
+				body,
+				status: response.status
 			}
 		}));
 	}));
 };
-const jsonBody = (body) => HttpBody.unsafeJson(body);
+const jsonBody = (body) => HttpBody.jsonUnsafe(body);
+const urlEncodedBody = (body) => HttpBody.urlParams(UrlParams.fromInput(body));
 
 //#endregion
-export { authorizedClient, checkStatus, handleJsonResponse, jsonBody, makeUrl };
+export { authorizedClient, checkStatus, handleJsonResponse, jsonBody, makeUrl, urlEncodedBody };