@herd-labs/sdk 0.1.0 → 0.2.0

package/dist/src/live/GroupsServiceLive.js

@@ -11,14 +11,14 @@ const mapNotFound = (groupId) => Effect.catchAll((error) => {
 	return Effect.fail(error);
 });
 const GroupsServiceLive = Layer.effect(GroupsService, Effect.gen(function* () {
-	const { config, client } = yield* authorizedClient;
+	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: ({ params }) => pipe(client.post(makeUrl(config.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(config.baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponse)), Effect.mapError(ensureServiceError("Failed to list groups"))),
-		get: ({ groupId }) => pipe(client.get(makeUrl(config.baseUrl, `/v1/groups/${groupId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GroupDetails)), Effect.mapError(ensureServiceError("Failed to get group")), mapNotFound(groupId)),
-		proposeMemberChange: ({ groupId, params }) => pipe(client.post(makeUrl(config.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(config.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(config.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))
+		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"))),
+		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)),
+		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))
 	};
 }));
 

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_HttpClient11 from "@effect/platform/HttpClient";
+import * as _effect_platform_HttpClient13 from "@effect/platform/HttpClient";
 
 //#region src/live/HalServiceLive.d.ts
-declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfig | _effect_platform_HttpClient11.HttpClient>;
+declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfig | _effect_platform_HttpClient13.HttpClient>;
 //#endregion
 export { HalServiceLive };

package/dist/src/live/HalServiceLive.js

@@ -14,9 +14,9 @@ const mapSimulationError = Effect.catchAll((error) => {
 	return Effect.fail(error);
 });
 const HalServiceLive = Layer.effect(HalService, Effect.gen(function* () {
-	const { config, client } = yield* authorizedClient;
-	const callEvaluate = (body) => pipe(client.post(makeUrl(config.baseUrl, "/v1/actions/executions/evaluate"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateResponse)), Effect.mapError(ensureServiceError("Failed to evaluate expression")), mapSimulationError);
-	const callEvaluateExisting = (body) => pipe(client.post(makeUrl(config.baseUrl, "/v1/actions/executions/evaluate/existing"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateExistingResponse)), Effect.mapError(ensureServiceError("Failed to evaluate existing action")), mapSimulationError);
+	const { baseUrl, client } = yield* authorizedClient;
+	const callEvaluate = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateResponse)), Effect.mapError(ensureServiceError("Failed to evaluate expression")), mapSimulationError);
+	const callEvaluateExisting = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate/existing"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateExistingResponse)), Effect.mapError(ensureServiceError("Failed to evaluate existing action")), mapSimulationError);
 	return {
 		evaluate: (params) => callEvaluate({
 			expression: params.expression,

package/dist/src/live/TransactionsServiceLive.js

@@ -23,17 +23,17 @@ const latestTxParamsToSnakeCaseQuery = (params) => pipe({
 	called_by: params?.calledBy
 }, Record.filterMap(Option.liftNullable(Function.identity)));
 const TransactionsServiceLive = Layer.effect(TransactionsService, Effect.gen(function* () {
-	const { config, client } = yield* authorizedClient;
+	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		getTransaction: (blockchain, txHash) => pipe(client.get(makeUrl(config.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(config.baseUrl, `/v1/contracts/${blockchain}/${address}/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"))),
+		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(LatestFunctionTransactions)), Effect.mapError(ensureServiceError("Failed to get latest function transactions"))),
-		getLatestEventTransactions: (blockchain, address, filter, params) => pipe(client.get(makeUrl(config.baseUrl, `/v1/contracts/${blockchain}/${address}/latest_event_transactions`, {
+		getLatestEventTransactions: (blockchain, address, filter, params) => pipe(client.get(makeUrl(baseUrl, `/v1/contracts/${blockchain}/${address}/latest_event_transactions`, {
 			...latestTxParamsToSnakeCaseQuery(params),
 			...toOptionalQuery({
 				name: filter.name,

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_HttpClient13 from "@effect/platform/HttpClient";
+import * as _effect_platform_HttpClient4 from "@effect/platform/HttpClient";
 
 //#region src/live/WalletsServiceLive.d.ts
-declare const WalletsServiceLive: Layer.Layer<WalletsService, never, HerdConfig | _effect_platform_HttpClient13.HttpClient>;
+declare const WalletsServiceLive: Layer.Layer<WalletsService, never, HerdConfig | _effect_platform_HttpClient4.HttpClient>;
 //#endregion
 export { WalletsServiceLive };

package/dist/src/live/WalletsServiceLive.js

@@ -7,15 +7,15 @@ import { HttpClientResponse } from "@effect/platform";
 
 //#region src/live/WalletsServiceLive.ts
 const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* () {
-	const { config, client } = yield* authorizedClient;
+	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		getOverview: (blockchain, address, params) => pipe(client.get(makeUrl(config.baseUrl, `/v1/wallets/${blockchain}/${address}/overview`, {
+		getOverview: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/overview`, {
 			before_timestamp: params?.beforeTimestamp,
 			after_timestamp: params?.afterTimestamp,
 			before_blocknumber: params?.beforeBlocknumber,
 			after_blocknumber: params?.afterBlocknumber
 		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WalletOverview)), Effect.mapError(ensureServiceError("Failed to get wallet overview"))),
-		getTokenActivity: (blockchain, address, tokenAddress, params) => pipe(client.get(makeUrl(config.baseUrl, `/v1/wallets/${blockchain}/${address}/tokens/${tokenAddress}`, {
+		getTokenActivity: (blockchain, address, tokenAddress, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/tokens/${tokenAddress}`, {
 			page: params?.page,
 			before_timestamp: params?.beforeTimestamp,
 			after_timestamp: params?.afterTimestamp,
@@ -34,13 +34,13 @@ const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* ()
 				after_blocknumber: query.afterBlocknumber,
 				success_only: query.successOnly === true ? true : void 0
 			}, Record.filterMap(Option.liftNullable(Function.identity)));
-			return pipe(client.post(makeUrl(config.baseUrl, "/v1/wallets/transaction-activity"), { body: jsonBody({
+			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(config.baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, {
+		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,

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

@@ -7,10 +7,7 @@ import * as _effect_platform_HttpClientError0 from "@effect/platform/HttpClientE
 //#region src/live/http.d.ts
 declare const makeUrl: (baseUrl: string, path: string, queryParams?: object) => string;
 declare const authorizedClient: Effect.Effect<{
-  config: {
-    readonly baseUrl: string;
-    readonly accessToken: string;
-  };
+  baseUrl: string;
   client: HttpClient.HttpClient.With<_effect_platform_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>;

package/dist/src/live/http.js

@@ -1,6 +1,6 @@
 import { HerdConfig } from "../config.js";
 import { ServiceError } from "../errors.js";
-import { Effect, pipe } from "effect";
+import { Effect, Either, pipe } from "effect";
 import { HttpBody, HttpClient, HttpClientRequest, HttpClientResponse } from "@effect/platform";
 
 //#region src/live/http.ts
@@ -14,10 +14,21 @@ 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}` }
+		}),
+		onRight: ({ baseUrl: baseUrl$1, apiKey }) => ({
+			baseUrl: baseUrl$1,
+			authHeaders: { "x-api-key": apiKey }
+		})
+	});
 	return {
-		config,
-		client: (yield* HttpClient.HttpClient).pipe(HttpClient.mapRequest(HttpClientRequest.setHeaders({
-			Authorization: `Bearer ${config.accessToken}`,
+		baseUrl,
+		client: client.pipe(HttpClient.mapRequest(HttpClientRequest.setHeaders({
+			...authHeaders,
 			"Content-Type": "application/json"
 		})))
 	};

package/dist/src/schemas/actions.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import * as effect_Brand14 from "effect/Brand";
+import * as effect_Brand0 from "effect/Brand";
 
 //#region src/schemas/actions.d.ts
 declare const ActionExpression_base: Schema.Class<ActionExpression, {
@@ -26,10 +26,10 @@ declare const ActionExpression_base: Schema.Class<ActionExpression, {
   readonly id: string;
 } & {
   readonly name: string;
-} & {
-  readonly intent?: string | undefined;
 } & {
   readonly expression: unknown;
+} & {
+  readonly intent?: string | undefined;
 } & {
   readonly publishedAt?: string | null | undefined;
 }, {}, {}>;
@@ -102,10 +102,10 @@ declare const ActionVersion_base: Schema.Class<ActionVersion, {
   readonly id: string;
 } & {
   readonly name: string;
-} & {
-  readonly intent?: string | undefined;
 } & {
   readonly expression: unknown;
+} & {
+  readonly intent?: string | undefined;
 } & {
   readonly publishedAt?: string | null | undefined;
 }, {}, {}>;
@@ -127,11 +127,11 @@ declare const ActionsSearchParams_base: Schema.Class<ActionsSearchParams, {
     expressionType: Schema.optional<Schema.Literal<["action", "adapter"]>>;
   }>>;
 }>, never, {
-  readonly limit: number;
-} & {
   readonly offset: number;
 } & {
   readonly scope: readonly ("yours" | "all_published" | "verified")[];
+} & {
+  readonly limit: number;
 } & {
   readonly filters?: {
     readonly name?: string | undefined;
@@ -233,13 +233,13 @@ declare const RelatedAdaptersSearchParams_base: Schema.Class<RelatedAdaptersSear
   }>>;
   scope: Schema.Array$<Schema.Literal<["yours", "verified"]>>;
 }>, never, {
+  readonly scope: readonly ("yours" | "verified")[];
+} & {
   readonly contracts: readonly {
     readonly blockchain?: "ethereum" | "base" | undefined;
-    readonly address: string & effect_Brand14.Brand<"EvmAddress">;
     readonly functionSignatures?: readonly string[] | undefined;
+    readonly address: string & effect_Brand0.Brand<"EvmAddress">;
   }[];
-} & {
-  readonly scope: readonly ("yours" | "verified")[];
 }, {}, {}>;
 declare class RelatedAdaptersSearchParams extends RelatedAdaptersSearchParams_base {}
 declare const CreateActionParams_base: Schema.Class<CreateActionParams, {
@@ -252,10 +252,10 @@ declare const CreateActionParams_base: Schema.Class<CreateActionParams, {
   expression: typeof Schema.Unknown;
 }>, never, {
   readonly name: string;
-} & {
-  readonly intent?: string | undefined;
 } & {
   readonly expression: unknown;
+} & {
+  readonly intent?: string | undefined;
 }, {}, {}>;
 declare class CreateActionParams extends CreateActionParams_base {}
 declare const CreateActionResponse_base: Schema.Class<CreateActionResponse, {

package/dist/src/schemas/adapters.d.ts

@@ -11,10 +11,10 @@ declare const CreateAdapterParams_base: Schema.Class<CreateAdapterParams, {
   expression: typeof Schema.Unknown;
 }>, never, {
   readonly name: string;
-} & {
-  readonly intent?: string | undefined;
 } & {
   readonly expression: unknown;
+} & {
+  readonly intent?: string | undefined;
 }, {}, {}>;
 declare class CreateAdapterParams extends CreateAdapterParams_base {}
 //#endregion

package/dist/src/schemas/agent-wallets.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import * as effect_Brand3 from "effect/Brand";
+import * as effect_Brand0 from "effect/Brand";
 
 //#region src/schemas/agent-wallets.d.ts
 declare const AgentWallet_base: Schema.Class<AgentWallet, {
@@ -16,12 +16,12 @@ declare const AgentWallet_base: Schema.Class<AgentWallet, {
   intent: Schema.NullOr<typeof Schema.String>;
 }>, never, {
   readonly id: string;
-} & {
-  readonly address: string & effect_Brand3.Brand<"EvmAddress">;
 } & {
   readonly name: string | null;
 } & {
   readonly intent: string | null;
+} & {
+  readonly address: string & effect_Brand0.Brand<"EvmAddress">;
 } & {
   readonly groupId: string;
 }, {}, {}>;
@@ -41,13 +41,13 @@ declare const AgentWalletSafe_base: Schema.Class<AgentWalletSafe, {
   isProposer: typeof Schema.Boolean;
   isSigner: typeof Schema.Boolean;
 }>, never, {
-  readonly blockchain: "ethereum" | "base";
-} & {
   readonly name: string | null;
 } & {
   readonly intent: string | null;
 } & {
-  readonly safeAddress: string & effect_Brand3.Brand<"EvmAddress">;
+  readonly blockchain: "ethereum" | "base";
+} & {
+  readonly safeAddress: string & effect_Brand0.Brand<"EvmAddress">;
 } & {
   readonly isProposer: boolean;
 } & {
@@ -69,11 +69,11 @@ declare const LinkedAgentWallet_base: Schema.Class<LinkedAgentWallet, {
   isProposer: typeof Schema.Boolean;
   isSigner: typeof Schema.Boolean;
 }>, never, {
-  readonly address: string & effect_Brand3.Brand<"EvmAddress">;
-} & {
   readonly name: string | null;
 } & {
   readonly intent: string | null;
+} & {
+  readonly address: string & effect_Brand0.Brand<"EvmAddress">;
 } & {
   readonly isProposer: boolean;
 } & {
@@ -93,13 +93,13 @@ declare const AgentSafeMetadata_base: Schema.Class<AgentSafeMetadata, {
   name: Schema.NullOr<typeof Schema.String>;
   intent: Schema.NullOr<typeof Schema.String>;
 }>, never, {
-  readonly blockchain: "ethereum" | "base";
-} & {
   readonly name: string | null;
 } & {
   readonly intent: string | null;
 } & {
-  readonly safeAddress: string & effect_Brand3.Brand<"EvmAddress">;
+  readonly blockchain: "ethereum" | "base";
+} & {
+  readonly safeAddress: string & effect_Brand0.Brand<"EvmAddress">;
 }, {}, {}>;
 declare class AgentSafeMetadata extends AgentSafeMetadata_base {}
 declare const AgentWalletsListParams_base: Schema.Class<AgentWalletsListParams, {
@@ -145,13 +145,13 @@ declare const AgentSafe_base: Schema.Class<AgentSafe, {
   threshold: typeof Schema.Number;
   safeUrl: typeof Schema.String;
 }>, never, {
-  readonly blockchain: "ethereum" | "base";
-} & {
   readonly name: string | null;
 } & {
   readonly intent: string | null;
 } & {
-  readonly safeAddress: string & effect_Brand3.Brand<"EvmAddress">;
+  readonly blockchain: "ethereum" | "base";
+} & {
+  readonly safeAddress: string & effect_Brand0.Brand<"EvmAddress">;
 } & {
   readonly threshold: number;
 } & {
@@ -159,7 +159,7 @@ declare const AgentSafe_base: Schema.Class<AgentSafe, {
 } & {
   readonly linkedAgentWallets: readonly LinkedAgentWallet[];
 } & {
-  readonly owners: readonly (string & effect_Brand3.Brand<"EvmAddress">)[];
+  readonly owners: readonly (string & effect_Brand0.Brand<"EvmAddress">)[];
 }, {}, {}>;
 declare class AgentSafe extends AgentSafe_base {}
 declare const SetSafeProposerParams_base: Schema.Class<SetSafeProposerParams, {
@@ -175,7 +175,7 @@ declare const SetSafeProposerParams_base: Schema.Class<SetSafeProposerParams, {
 } & {
   readonly intent?: string | undefined;
 } & {
-  readonly agentWalletAddress: string & effect_Brand3.Brand<"EvmAddress">;
+  readonly agentWalletAddress: string & effect_Brand0.Brand<"EvmAddress">;
 }, {}, {}>;
 declare class SetSafeProposerParams extends SetSafeProposerParams_base {}
 declare const SetSafeProposerResponse_base: Schema.Class<SetSafeProposerResponse, {
@@ -195,19 +195,19 @@ declare const SetSafeProposerResponse_base: Schema.Class<SetSafeProposerResponse
   isProposer: typeof Schema.Boolean;
   isSigner: typeof Schema.Boolean;
 }>, never, {
-  readonly blockchain: "ethereum" | "base";
-} & {
   readonly name: string | null;
 } & {
   readonly intent: string | null;
 } & {
-  readonly safeAddress: string & effect_Brand3.Brand<"EvmAddress">;
+  readonly blockchain: "ethereum" | "base";
+} & {
+  readonly safeAddress: string & effect_Brand0.Brand<"EvmAddress">;
 } & {
   readonly isProposer: boolean;
 } & {
   readonly isSigner: boolean;
 } & {
-  readonly agentWalletAddress: string & effect_Brand3.Brand<"EvmAddress">;
+  readonly agentWalletAddress: string & effect_Brand0.Brand<"EvmAddress">;
 }, {}, {}>;
 declare class SetSafeProposerResponse extends SetSafeProposerResponse_base {}
 declare const EditAgentSafeMetadataParams_base: Schema.Class<EditAgentSafeMetadataParams, {

package/dist/src/schemas/auth.d.ts

@@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import { ApiKey as ApiKey$1 } from "@better-auth/api-key/types";
 
 //#region src/schemas/auth.d.ts
 declare const FeatureFlagsSchema: Schema.Struct<{
@@ -47,17 +48,26 @@ declare const TokenResponse_base: Schema.Class<TokenResponse, {
   readonly expiresIn: number;
 }, {}, {}>;
 declare class TokenResponse extends TokenResponse_base {}
-declare const ApiKeyResponse_base: Schema.Class<ApiKeyResponse, {
-  keyId: typeof Schema.String;
-  apiKey: typeof Schema.String;
-}, Schema.Struct.Encoded<{
+type ApiKeyType = Pick<ApiKey$1, "id" | "name" | "start" | "createdAt" | "lastRequest">;
+type ApiKeyEncoded = { [K in keyof ApiKeyType]: ApiKeyType[K] extends Date ? string : ApiKeyType[K] extends Date | null ? string | null : ApiKeyType[K] };
+declare const ApiKey: Schema.Schema<ApiKeyType, ApiKeyEncoded>;
+declare const CreatedApiKey: Schema.Struct<{
+  id: typeof Schema.String;
+  key: typeof Schema.String;
+  name: Schema.NullOr<typeof Schema.String>;
+}>;
+type CreatedApiKeyType = typeof CreatedApiKey.Type;
+declare const ApiKeyListResponse: Schema.Struct<{
+  apiKeys: Schema.Array$<Schema.Schema<ApiKeyType, ApiKeyEncoded, never>>;
+}>;
+type ApiKeyListResponseType = typeof ApiKeyListResponse.Type;
+declare const CreateApiKeyParams: Schema.Struct<{
+  name: Schema.optional<typeof Schema.String>;
+}>;
+type CreateApiKeyParamsType = typeof CreateApiKeyParams.Type;
+declare const DeleteApiKeyParams: Schema.Struct<{
   keyId: typeof Schema.String;
-  apiKey: typeof Schema.String;
-}>, never, {
-  readonly keyId: string;
-} & {
-  readonly apiKey: string;
-}, {}, {}>;
-declare class ApiKeyResponse extends ApiKeyResponse_base {}
+}>;
+type DeleteApiKeyParamsType = typeof DeleteApiKeyParams.Type;
 //#endregion
-export { ApiKeyResponse, FeatureFlags, FeatureFlagsSchema, TokenResponse, WhoamiResponse };
+export { ApiKey, ApiKeyListResponse, ApiKeyListResponseType, ApiKeyType, CreateApiKeyParams, CreateApiKeyParamsType, CreatedApiKey, CreatedApiKeyType, DeleteApiKeyParams, DeleteApiKeyParamsType, FeatureFlags, FeatureFlagsSchema, TokenResponse, WhoamiResponse };

package/dist/src/schemas/auth.js

@@ -13,10 +13,21 @@ var TokenResponse = class extends Schema.Class("TokenResponse")({
 	expiresIn: Schema.Number,
 	tokenType: Schema.String
 }) {};
-var ApiKeyResponse = class extends Schema.Class("ApiKeyResponse")({
-	keyId: Schema.String,
-	apiKey: Schema.String
-}) {};
+const ApiKey = Schema.Struct({
+	id: Schema.String,
+	name: Schema.NullOr(Schema.String),
+	start: Schema.NullOr(Schema.String),
+	createdAt: Schema.DateFromString,
+	lastRequest: Schema.NullOr(Schema.DateFromString)
+});
+const CreatedApiKey = Schema.Struct({
+	id: Schema.String,
+	key: Schema.String,
+	name: Schema.NullOr(Schema.String)
+});
+const ApiKeyListResponse = Schema.Struct({ apiKeys: Schema.Array(ApiKey) });
+const CreateApiKeyParams = Schema.Struct({ name: Schema.optional(Schema.String) });
+const DeleteApiKeyParams = Schema.Struct({ keyId: Schema.String });
 
 //#endregion
-export { ApiKeyResponse, FeatureFlagsSchema, TokenResponse, WhoamiResponse };
+export { ApiKey, ApiKeyListResponse, CreateApiKeyParams, CreatedApiKey, DeleteApiKeyParams, FeatureFlagsSchema, TokenResponse, WhoamiResponse };

package/dist/src/schemas/bookmarks.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import * as effect_Brand0 from "effect/Brand";
+import * as effect_Brand9 from "effect/Brand";
 
 //#region src/schemas/bookmarks.d.ts
 declare const BookmarkObjectType: Schema.Literal<["contract", "transaction", "wallet"]>;
@@ -62,10 +62,10 @@ declare const TransactionBookmark_base: Schema.Class<TransactionBookmark, {
   readonly createdAt: string;
 } & {
   readonly updatedAt: string;
-} & {
-  readonly userLabel: string | null;
 } & {
   readonly transactionHash: string;
+} & {
+  readonly userLabel: string | null;
 }, {}, {}>;
 declare class TransactionBookmark extends TransactionBookmark_base {}
 declare const WalletBookmark_base: Schema.Class<WalletBookmark, {
@@ -82,14 +82,14 @@ declare const WalletBookmark_base: Schema.Class<WalletBookmark, {
   updatedAt: typeof Schema.String;
 }>, never, {
   readonly id: string;
+} & {
+  readonly walletAddress: string;
 } & {
   readonly createdAt: string;
 } & {
   readonly updatedAt: string;
 } & {
   readonly userLabel: string | null;
-} & {
-  readonly walletAddress: string;
 }, {}, {}>;
 declare class WalletBookmark extends WalletBookmark_base {}
 declare const BookmarksList_base: Schema.Class<BookmarksList, {
@@ -140,9 +140,9 @@ declare const AddContractBookmarkParams_base: Schema.Class<AddContractBookmarkPa
 }>, never, {
   readonly blockchain: "ethereum" | "base";
 } & {
-  readonly label?: string | undefined;
+  readonly address: string & effect_Brand9.Brand<"EvmAddress">;
 } & {
-  readonly address: string & effect_Brand0.Brand<"EvmAddress">;
+  readonly label?: string | undefined;
 }, {}, {}>;
 declare class AddContractBookmarkParams extends AddContractBookmarkParams_base {}
 declare const AddTransactionBookmarkParams_base: Schema.Class<AddTransactionBookmarkParams, {
@@ -168,9 +168,9 @@ declare const AddWalletBookmarkParams_base: Schema.Class<AddWalletBookmarkParams
   address: Schema.brand<Schema.filter<typeof Schema.String>, "EvmAddress">;
   label: Schema.optional<typeof Schema.String>;
 }>, never, {
-  readonly label?: string | undefined;
+  readonly address: string & effect_Brand9.Brand<"EvmAddress">;
 } & {
-  readonly address: string & effect_Brand0.Brand<"EvmAddress">;
+  readonly label?: string | undefined;
 }, {}, {}>;
 declare class AddWalletBookmarkParams extends AddWalletBookmarkParams_base {}
 declare const UpdateBookmarkLabelParams_base: Schema.Class<UpdateBookmarkLabelParams, {
@@ -188,11 +188,11 @@ declare const UpdateBookmarkLabelParams_base: Schema.Class<UpdateBookmarkLabelPa
 }>, never, {
   readonly blockchain?: "ethereum" | "base" | undefined;
 } & {
-  readonly label: string | null;
+  readonly address?: string | undefined;
 } & {
-  readonly objectType: "contract" | "transaction" | "wallet";
+  readonly label: string | null;
 } & {
-  readonly address?: string | undefined;
+  readonly objectType: "wallet" | "contract" | "transaction";
 } & {
   readonly txHash?: string | undefined;
 }, {}, {}>;
@@ -209,10 +209,10 @@ declare const DeleteBookmarkParams_base: Schema.Class<DeleteBookmarkParams, {
   blockchain: Schema.optional<Schema.Literal<["ethereum", "base"]>>;
 }>, never, {
   readonly blockchain?: "ethereum" | "base" | undefined;
-} & {
-  readonly objectType: "contract" | "transaction" | "wallet";
 } & {
   readonly address?: string | undefined;
+} & {
+  readonly objectType: "wallet" | "contract" | "transaction";
 } & {
   readonly txHash?: string | undefined;
 }, {}, {}>;

package/dist/src/schemas/codeblocks.d.ts

@@ -96,9 +96,9 @@ declare const CodeBlocksSearchParams_base: Schema.Class<CodeBlocksSearchParams,
     name: Schema.optional<typeof Schema.String>;
   }>>;
 }>, never, {
-  readonly limit: number;
-} & {
   readonly scope: "user" | "public";
+} & {
+  readonly limit: number;
 } & {
   readonly filters?: {
     readonly name?: string | undefined;

package/dist/src/schemas/collections.d.ts

@@ -92,11 +92,11 @@ declare const CollectionsSearchParams_base: Schema.Class<CollectionsSearchParams
     name: Schema.optional<typeof Schema.String>;
   }>>;
 }>, never, {
-  readonly limit: number;
-} & {
   readonly offset: number;
 } & {
   readonly scope?: readonly ("yours" | "verified" | "all")[] | undefined;
+} & {
+  readonly limit: number;
 } & {
   readonly filters?: {
     readonly name?: string | undefined;