@herd-labs/sdk 0.0.4 → 0.1.0

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

@@ -19,12 +19,12 @@ declare const WalletBalance_base: Schema.Class<WalletBalance, {
   readonly symbol: string | null;
 } & {
   readonly address: string;
-} & {
-  readonly amount: string | number;
 } & {
   readonly decimals: number | null;
 } & {
   readonly valueUsd: number | null;
+} & {
+  readonly amount: string | number;
 } & {
   readonly logoUrl: string | null;
 }, {}, {}>;
@@ -38,9 +38,9 @@ declare const Erc7702Delegation_base: Schema.Class<Erc7702Delegation, {
   contractName: typeof Schema.String;
   functions: Schema.Array$<typeof Schema.String>;
 }>, never, {
-  readonly address: string;
-} & {
   readonly contractName: string;
+} & {
+  readonly address: string;
 } & {
   readonly functions: readonly string[];
 }, {}, {}>;
@@ -83,14 +83,14 @@ declare const PendingTransaction_base: Schema.Class<PendingTransaction, {
   readonly value: string;
 } & {
   readonly method?: string | null | undefined;
-} & {
-  readonly to: string;
 } & {
   readonly data: string | null;
-} & {
-  readonly safeTxHash: string;
 } & {
   readonly nonce: number;
+} & {
+  readonly to: string;
+} & {
+  readonly safeTxHash: string;
 } & {
   readonly submissionDate?: string | undefined;
 } & {
@@ -144,13 +144,13 @@ declare const WalletOverview_base: Schema.Class<WalletOverview, {
 } & {
   readonly walletAddress: string;
 } & {
-  readonly totalTransactionCount: number;
+  readonly implementationAddress?: string | undefined;
 } & {
   readonly totalDeployedContractsCount: number;
 } & {
-  readonly walletType: "eoa" | "erc7702" | "erc4337" | "multisig" | "contract";
+  readonly totalTransactionCount: number;
 } & {
-  readonly implementationAddress?: string | undefined;
+  readonly walletType: "contract" | "eoa" | "erc7702" | "erc4337" | "multisig";
 } & {
   readonly erc7702Delegation?: Erc7702Delegation | undefined;
 } & {
@@ -210,19 +210,19 @@ declare const TokenTransfer_base: Schema.Class<TokenTransfer, {
 } & {
   readonly blockTimestamp: number;
 } & {
-  readonly amount: string;
+  readonly blockTimestampUtc: string;
+} & {
+  readonly logIndex: number;
 } & {
   readonly fromAddress: string;
 } & {
   readonly toAddress: string;
 } & {
-  readonly blockTimestampUtc: string;
+  readonly amount: string;
 } & {
-  readonly logIndex: number;
+  readonly direction: "in" | "out";
 } & {
   readonly formattedAmount: string;
-} & {
-  readonly direction: "in" | "out";
 }, {}, {}>;
 declare class TokenTransfer extends TokenTransfer_base {}
 declare const TokenActivityPagination_base: Schema.Class<TokenActivityPagination, {
@@ -257,14 +257,14 @@ declare const TokenActivity_base: Schema.Class<TokenActivity, {
   pagination: typeof TokenActivityPagination;
 }>, never, {
   readonly blockchain: "ethereum" | "base";
-} & {
-  readonly tokenAddress: string;
-} & {
-  readonly holderAddress: string;
 } & {
   readonly balance: TokenBalanceInfo;
 } & {
   readonly pagination: TokenActivityPagination;
+} & {
+  readonly tokenAddress: string;
+} & {
+  readonly holderAddress: string;
 } & {
   readonly transfers: readonly TokenTransfer[];
 }, {}, {}>;
@@ -282,15 +282,15 @@ declare const WalletTxCall_base: Schema.Class<WalletTxCall, {
   contractName: Schema.NullOr<typeof Schema.String>;
   entityLabel: Schema.NullOr<typeof Schema.String>;
 }>, never, {
-  readonly functionSignature: string;
-} & {
   readonly contractName: string | null;
 } & {
-  readonly callee: string;
+  readonly functionSignature: string;
+} & {
+  readonly entityLabel: string | null;
 } & {
   readonly functionName: string;
 } & {
-  readonly entityLabel: string | null;
+  readonly callee: string;
 }, {}, {}>;
 declare class WalletTxCall extends WalletTxCall_base {}
 declare const WalletTxActionExecution_base: Schema.Class<WalletTxActionExecution, {
@@ -305,10 +305,10 @@ declare const WalletTxActionExecution_base: Schema.Class<WalletTxActionExecution
   executionId: typeof Schema.String;
 }>, never, {
   readonly actionId: string;
-} & {
-  readonly actionName: string;
 } & {
   readonly versionId: string;
+} & {
+  readonly actionName: string;
 } & {
   readonly executionId: string;
 }, {}, {}>;
@@ -356,17 +356,17 @@ declare const WalletTxTransfer_base: Schema.Class<WalletTxTransfer, {
 }>, never, {
   readonly txHash: string;
 } & {
-  readonly tokenAddress: string;
+  readonly tokenType: "ERC20" | "ERC721" | "ERC1155" | "NATIVE";
 } & {
   readonly blockNumber: number;
 } & {
   readonly blockTimestamp: number;
 } & {
-  readonly amount: number;
+  readonly toEntityLabel?: string | null | undefined;
 } & {
-  readonly fromAddress: string;
+  readonly fromEntityLabel?: string | null | undefined;
 } & {
-  readonly toAddress: string;
+  readonly tokenAddress: string;
 } & {
   readonly chainId: number;
 } & {
@@ -382,15 +382,15 @@ declare const WalletTxTransfer_base: Schema.Class<WalletTxTransfer, {
 } & {
   readonly tokenLogoUrl: string;
 } & {
-  readonly tokenType: "NATIVE" | "ERC20" | "ERC721" | "ERC1155";
+  readonly fromAddress: string;
 } & {
-  readonly fromAddressIsContract: boolean;
+  readonly toAddress: string;
 } & {
-  readonly toAddressIsContract: boolean;
+  readonly amount: number;
 } & {
-  readonly fromEntityLabel?: string | null | undefined;
+  readonly fromAddressIsContract: boolean;
 } & {
-  readonly toEntityLabel?: string | null | undefined;
+  readonly toAddressIsContract: boolean;
 }, {}, {}>;
 declare class WalletTxTransfer extends WalletTxTransfer_base {}
 declare const WalletTxBalanceChange_base: Schema.Class<WalletTxBalanceChange, {
@@ -434,15 +434,15 @@ declare const WalletTxBalanceChange_base: Schema.Class<WalletTxBalanceChange, {
 }>, never, {
   readonly txHash?: string | undefined;
 } & {
-  readonly tokenAddress: string;
+  readonly tokenType: "ERC20" | "ERC721" | "ERC1155" | "NATIVE";
 } & {
   readonly blockNumber: number;
 } & {
   readonly blockTimestamp: number;
 } & {
-  readonly holderAddress: string;
+  readonly tokenAddress: string;
 } & {
-  readonly transfers: readonly WalletTxTransfer[];
+  readonly holderAddress: string;
 } & {
   readonly holderIsContract: boolean;
 } & {
@@ -461,12 +461,12 @@ declare const WalletTxBalanceChange_base: Schema.Class<WalletTxBalanceChange, {
   readonly tokenPriceUsd: number;
 } & {
   readonly tokenLogoUrl: string;
-} & {
-  readonly tokenType: "NATIVE" | "ERC20" | "ERC721" | "ERC1155";
 } & {
   readonly holderEntityLabel?: string | null | undefined;
 } & {
   readonly tokenEntityLabel?: string | null | undefined;
+} & {
+  readonly transfers: readonly WalletTxTransfer[];
 }, {}, {}>;
 declare class WalletTxBalanceChange extends WalletTxBalanceChange_base {}
 declare const WalletTransaction_base: Schema.Class<WalletTransaction, {
@@ -502,7 +502,7 @@ declare const WalletTransaction_base: Schema.Class<WalletTransaction, {
 }>, never, {
   readonly txHash: string;
 } & {
-  readonly success: boolean;
+  readonly errorMessage?: string | undefined;
 } & {
   readonly blockNumber: number;
 } & {
@@ -510,19 +510,19 @@ declare const WalletTransaction_base: Schema.Class<WalletTransaction, {
 } & {
   readonly blockTimestampUtc: string;
 } & {
-  readonly errorMessage?: string | undefined;
-} & {
-  readonly calls: readonly WalletTxCall[];
-} & {
-  readonly walletBalanceChanges: readonly WalletTxBalanceChange[];
+  readonly success: boolean;
 } & {
   readonly createdContracts: readonly {
-    readonly address: string;
     readonly contractName: string | null;
+    readonly address: string;
     readonly entityLabel: string | null;
   }[];
 } & {
   readonly actionExecution?: WalletTxActionExecution | undefined;
+} & {
+  readonly calls: readonly WalletTxCall[];
+} & {
+  readonly walletBalanceChanges: readonly WalletTxBalanceChange[];
 }, {}, {}>;
 declare class WalletTransaction extends WalletTransaction_base {}
 declare const TransactionActivityPagination_base: Schema.Class<TransactionActivityPagination, {
@@ -560,17 +560,17 @@ declare const TransactionActivity_base: Schema.Class<TransactionActivity, {
 }>, never, {
   readonly blockchain: "ethereum" | "base";
 } & {
-  readonly totalTransactionCount: number;
+  readonly transactions: readonly WalletTransaction[];
 } & {
-  readonly earliestTx: number | null;
+  readonly pagination: TransactionActivityPagination;
 } & {
   readonly fromAddress: string;
 } & {
-  readonly pagination: TransactionActivityPagination;
+  readonly totalTransactionCount: number;
 } & {
-  readonly toAddressesFilter?: readonly string[] | undefined;
+  readonly earliestTx: number | null;
 } & {
-  readonly transactions: readonly WalletTransaction[];
+  readonly toAddressesFilter?: readonly string[] | undefined;
 }, {}, {}>;
 declare class TransactionActivity extends TransactionActivity_base {}
 declare const DeployedContract_base: Schema.Class<DeployedContract, {
@@ -599,12 +599,12 @@ declare const DeployedContract_base: Schema.Class<DeployedContract, {
   readonly symbol: string | null;
 } & {
   readonly contractAddress: string;
+} & {
+  readonly contractName: string | null;
 } & {
   readonly blockNumber: number;
 } & {
   readonly blockTimestamp: number;
-} & {
-  readonly contractName: string | null;
 } & {
   readonly blockTimestampUtc: string;
 } & {
@@ -649,14 +649,14 @@ declare const DeployedContracts_base: Schema.Class<DeployedContracts, {
   pagination: typeof DeployedContractsPagination;
 }>, never, {
   readonly blockchain: "ethereum" | "base";
-} & {
-  readonly totalDeployedContractsCount: number;
-} & {
-  readonly pagination: DeployedContractsPagination;
 } & {
   readonly deployerAddress: string;
 } & {
   readonly isEOA: boolean;
+} & {
+  readonly totalDeployedContractsCount: number;
+} & {
+  readonly pagination: DeployedContractsPagination;
 } & {
   readonly deployedContracts: readonly DeployedContract[];
 }, {}, {}>;
@@ -727,10 +727,10 @@ declare const TransactionActivityQuery_base: Schema.Class<TransactionActivityQue
   readonly afterBlocknumber?: number | undefined;
 } & {
   readonly fromAddress?: string | undefined;
-} & {
-  readonly toAddresses?: readonly string[] | undefined;
 } & {
   readonly successOnly?: boolean | undefined;
+} & {
+  readonly toAddresses?: readonly string[] | undefined;
 }, {}, {}>;
 /** Same fields as MCP `getTransactionActivityTool` inputs (camelCase); POST `/v1/wallets/transaction-activity` body uses snake_case. */
 declare class TransactionActivityQuery extends TransactionActivityQuery_base {}

package/dist/src/services/AgentSafesService.d.ts

@@ -0,0 +1,14 @@
+import { ServiceError } from "../errors.js";
+import { BlockchainType, EvmAddressType } from "../schemas/common.js";
+import { AgentSafe, AgentSafeMetadata, EditAgentSafeMetadataParams, SetSafeProposerParams, SetSafeProposerResponse } from "../schemas/agent-wallets.js";
+import { Context, Effect } from "effect";
+
+//#region src/services/AgentSafesService.d.ts
+declare const AgentSafesService_base: Context.TagClass<AgentSafesService, "AgentSafesService", {
+  readonly getAgentSafe: (blockchain: BlockchainType, safeAddress: EvmAddressType) => Effect.Effect<AgentSafe, ServiceError>;
+  readonly setSafeProposer: (blockchain: BlockchainType, safeAddress: EvmAddressType, params: SetSafeProposerParams) => Effect.Effect<SetSafeProposerResponse, ServiceError>;
+  readonly editAgentSafeMetadata: (blockchain: BlockchainType, safeAddress: EvmAddressType, params: EditAgentSafeMetadataParams) => Effect.Effect<AgentSafeMetadata, ServiceError>;
+}>;
+declare class AgentSafesService extends AgentSafesService_base {}
+//#endregion
+export { AgentSafesService };

package/dist/src/services/AgentSafesService.js

@@ -0,0 +1,7 @@
+import { Context, Effect } from "effect";
+
+//#region src/services/AgentSafesService.ts
+var AgentSafesService = class extends Context.Tag("AgentSafesService")() {};
+
+//#endregion
+export { AgentSafesService };

package/dist/src/services/AgentWalletsService.d.ts

@@ -0,0 +1,13 @@
+import { ServiceError } from "../errors.js";
+import { EvmAddressType } from "../schemas/common.js";
+import { AgentWalletSafesList, AgentWalletsList, AgentWalletsListParams } from "../schemas/agent-wallets.js";
+import { Context, Effect } from "effect";
+
+//#region src/services/AgentWalletsService.d.ts
+declare const AgentWalletsService_base: Context.TagClass<AgentWalletsService, "AgentWalletsService", {
+  readonly listAgentWallets: (params?: AgentWalletsListParams) => Effect.Effect<AgentWalletsList, ServiceError>;
+  readonly listAgentWalletSafes: (agentWalletAddress: EvmAddressType) => Effect.Effect<AgentWalletSafesList, ServiceError>;
+}>;
+declare class AgentWalletsService extends AgentWalletsService_base {}
+//#endregion
+export { AgentWalletsService };

package/dist/src/services/AgentWalletsService.js

@@ -0,0 +1,7 @@
+import { Context, Effect } from "effect";
+
+//#region src/services/AgentWalletsService.ts
+var AgentWalletsService = class extends Context.Tag("AgentWalletsService")() {};
+
+//#endregion
+export { AgentWalletsService };

package/dist/src/services/AgentWorkflowsService.d.ts

@@ -0,0 +1,27 @@
+import { ServiceError } from "../errors.js";
+import { AgentWorkflowWithRunsType, CreateAgentWorkflowParamsType, CreateAgentWorkflowResponseType, CreateAgentWorkflowRunParamsType, CreateAgentWorkflowRunResponseType, ExecuteSafeTxParamsType, ExecuteSafeTxResponseType, ListAgentWorkflowsParamsType, ListAgentWorkflowsResponseType, PushAgentWorkflowParamsType, PushAgentWorkflowResponseType, SubmitAgentWorkflowDecisionParamsType, SubmitAgentWorkflowDecisionResponseType } from "../schemas/agent-workflows.js";
+import { Context, Effect } from "effect";
+
+//#region src/services/AgentWorkflowsService.d.ts
+declare class AgentWorkflowNotFoundError extends Error {
+  readonly workflowId: string;
+  readonly _tag = "AgentWorkflowNotFoundError";
+  constructor(workflowId: string);
+}
+declare class AgentWorkflowRunNotFoundError extends Error {
+  readonly runId: string;
+  readonly _tag = "AgentWorkflowRunNotFoundError";
+  constructor(runId: string);
+}
+declare const AgentWorkflowsService_base: Context.TagClass<AgentWorkflowsService, "AgentWorkflowsService", {
+  readonly create: (params: CreateAgentWorkflowParamsType) => Effect.Effect<CreateAgentWorkflowResponseType, ServiceError>;
+  readonly list: (params: ListAgentWorkflowsParamsType) => Effect.Effect<ListAgentWorkflowsResponseType, ServiceError>;
+  readonly get: (agentWorkflowId: string) => Effect.Effect<AgentWorkflowWithRunsType, AgentWorkflowNotFoundError | ServiceError>;
+  readonly createRun: (params: CreateAgentWorkflowRunParamsType) => Effect.Effect<CreateAgentWorkflowRunResponseType, AgentWorkflowNotFoundError | ServiceError>;
+  readonly submitDecision: (params: SubmitAgentWorkflowDecisionParamsType) => Effect.Effect<SubmitAgentWorkflowDecisionResponseType, AgentWorkflowRunNotFoundError | ServiceError>;
+  readonly push: (params: PushAgentWorkflowParamsType) => Effect.Effect<PushAgentWorkflowResponseType, AgentWorkflowRunNotFoundError | ServiceError>;
+  readonly executeSafeTx: (params: ExecuteSafeTxParamsType) => Effect.Effect<ExecuteSafeTxResponseType, AgentWorkflowRunNotFoundError | ServiceError>;
+}>;
+declare class AgentWorkflowsService extends AgentWorkflowsService_base {}
+//#endregion
+export { AgentWorkflowNotFoundError, AgentWorkflowRunNotFoundError, AgentWorkflowsService };

package/dist/src/services/AgentWorkflowsService.js

@@ -0,0 +1,21 @@
+import { Context, Effect } from "effect";
+
+//#region src/services/AgentWorkflowsService.ts
+var AgentWorkflowNotFoundError = class extends Error {
+	_tag = "AgentWorkflowNotFoundError";
+	constructor(workflowId) {
+		super(`Agent workflow ${workflowId} not found`);
+		this.workflowId = workflowId;
+	}
+};
+var AgentWorkflowRunNotFoundError = class extends Error {
+	_tag = "AgentWorkflowRunNotFoundError";
+	constructor(runId) {
+		super(`Agent workflow run ${runId} not found`);
+		this.runId = runId;
+	}
+};
+var AgentWorkflowsService = class extends Context.Tag("AgentWorkflowsService")() {};
+
+//#endregion
+export { AgentWorkflowNotFoundError, AgentWorkflowRunNotFoundError, AgentWorkflowsService };

package/dist/src/services/ContractsService.d.ts

@@ -1,13 +1,12 @@
 import { ServiceError } from "../errors.js";
 import { BlockchainType, EvmAddressType, PaginationParams } from "../schemas/common.js";
-import { ContractDiff, ContractMetadata, DiffVersionsParams, GetContractCodeParams, GetContractCodeResponse, RolesTopology } from "../schemas/contracts.js";
+import { ContractDiff, ContractMetadata, DiffVersionsParams, GetContractCodeParams, GetContractCodeResponse } from "../schemas/contracts.js";
 import { DeployedContracts } from "../schemas/wallets.js";
 import { Context, Effect } from "effect";
 
 //#region src/services/ContractsService.d.ts
 declare const ContractsService_base: Context.TagClass<ContractsService, "ContractsService", {
   readonly getMetadata: (address: EvmAddressType, blockchain: BlockchainType) => Effect.Effect<ContractMetadata, ServiceError>;
-  readonly getRolesTopology: (address: EvmAddressType, blockchain: BlockchainType) => Effect.Effect<RolesTopology, ServiceError>;
   readonly diffVersions: (address: EvmAddressType, blockchain: BlockchainType, params?: DiffVersionsParams) => Effect.Effect<ContractDiff, ServiceError>;
   readonly getContractCode: (blockchain: BlockchainType, params: GetContractCodeParams) => Effect.Effect<GetContractCodeResponse, ServiceError>;
   readonly getDeployedContracts: (blockchain: BlockchainType, address: EvmAddressType, params?: PaginationParams) => Effect.Effect<DeployedContracts, ServiceError>;

package/dist/src/services/GroupsService.d.ts

@@ -0,0 +1,34 @@
+import { ServiceError } from "../errors.js";
+import { CreateGroupParamsType, CreateGroupResponseType, EditGroupMetadataParamsType, EditGroupMetadataResponseType, GroupDetailsType, ListGroupsResponseType, ProposalResponseType, ProposeMemberChangeParamsType, ProposeQuorumChangeParamsType } from "../schemas/groups.js";
+import { Context, Effect } from "effect";
+
+//#region src/services/GroupsService.d.ts
+declare class GroupNotFoundError extends Error {
+  readonly groupId: string;
+  readonly _tag = "GroupNotFoundError";
+  constructor(groupId: string);
+}
+declare const GroupsService_base: Context.TagClass<GroupsService, "GroupsService", {
+  readonly create: (params: {
+    params: CreateGroupParamsType;
+  }) => Effect.Effect<CreateGroupResponseType, ServiceError>;
+  readonly list: () => Effect.Effect<ListGroupsResponseType, ServiceError>;
+  readonly get: (params: {
+    groupId: string;
+  }) => Effect.Effect<GroupDetailsType, GroupNotFoundError | ServiceError>;
+  readonly proposeMemberChange: (params: {
+    groupId: string;
+    params: ProposeMemberChangeParamsType;
+  }) => Effect.Effect<ProposalResponseType, GroupNotFoundError | ServiceError>;
+  readonly proposeQuorumChange: (params: {
+    groupId: string;
+    params: ProposeQuorumChangeParamsType;
+  }) => Effect.Effect<ProposalResponseType, GroupNotFoundError | ServiceError>;
+  readonly editMetadata: (params: {
+    groupId: string;
+    params: EditGroupMetadataParamsType;
+  }) => Effect.Effect<EditGroupMetadataResponseType, GroupNotFoundError | ServiceError>;
+}>;
+declare class GroupsService extends GroupsService_base {}
+//#endregion
+export { GroupNotFoundError, GroupsService };

package/dist/src/services/GroupsService.js

@@ -0,0 +1,14 @@
+import { Context, Effect } from "effect";
+
+//#region src/services/GroupsService.ts
+var GroupNotFoundError = class extends Error {
+	_tag = "GroupNotFoundError";
+	constructor(groupId) {
+		super(`Group ${groupId} not found`);
+		this.groupId = groupId;
+	}
+};
+var GroupsService = class extends Context.Tag("GroupsService")() {};
+
+//#endregion
+export { GroupNotFoundError, GroupsService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herd-labs/sdk",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",