@agnocon/piece-blockscout 0.1.6

package/src/lib/actions/addresses/address-token-balances.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getAddressTokenBalances = createAction({
+  name: 'get_address_token_balances',
+  displayName: 'Get Address Token Balances',
+  description: 'Get list of token balances for an address',
+  audience: 'both',
+  aiMetadata: { description: 'Get the full current token holdings of an address as a flat list of balances. Choose this for a snapshot of what tokens an account holds and how much; use Get Address Token Transfers for movement history or Get Address Tokens for the paginated/filterable variant. Read-only lookup on eth.blockscout.com; requires a 0x address hash.', idempotent: true },
+  // category: 'Addresses',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Address Hash',
+      description: 'Hash of the address to fetch token balances for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/addresses/${context.propsValue.addressHash}/token-balances`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/addresses/address-token-transfers.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getAddressTokenTransfers = createAction({
+  name: 'get_address_token_transfers',
+  displayName: 'Get Address Token Transfers',
+  description: 'Get list of token transfers for an address',
+  audience: 'both',
+  aiMetadata: { description: 'List the token transfer events (ERC-20/721/1155) in which an address sent or received tokens. Pick this for token movement history; use Get Address Token Balances for current holdings or Get Address Transactions for native-coin transfers. Read-only lookup on eth.blockscout.com; requires a 0x address hash.', idempotent: true },
+  // category: 'Addresses',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Address Hash',
+      description: 'Hash of the address to fetch token transfers for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/addresses/${context.propsValue.addressHash}/token-transfers`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/addresses/address-tokens.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getAddressTokens = createAction({
+  name: 'get_address_tokens',
+  displayName: 'Get Address Tokens',
+  description: 'Get list of tokens owned by an address with filtering options',
+  audience: 'both',
+  aiMetadata: { description: 'List the tokens owned by an address, the paginated/filterable view of its holdings (e.g. by token type). Choose this when iterating through many holdings; use Get Address Token Balances for a simple full snapshot. Read-only lookup on eth.blockscout.com; requires a 0x address hash.', idempotent: true },
+  // category: 'Addresses',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Address Hash',
+      description: 'Hash of the address to fetch tokens for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/addresses/${context.propsValue.addressHash}/tokens`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/addresses/address-transactions.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getAddressTransactions = createAction({
+  name: 'get_address_transactions',
+  displayName: 'Get Address Transactions',
+  description: 'Get list of transactions for an address',
+  audience: 'both',
+  aiMetadata: { description: 'List the top-level transactions in which an address was the sender or receiver. Pick this for an account’s normal transaction history; use Get Address Internal Transactions for contract-internal value moves or Get Address Token Transfers for token movements. Read-only lookup on eth.blockscout.com; requires a 0x address hash.', idempotent: true },
+  // category: 'Addresses',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Address Hash',
+      description: 'Hash of the address to fetch transactions for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/addresses/${context.propsValue.addressHash}/transactions`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/addresses/address-withdrawals.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getAddressWithdrawals = createAction({
+  name: 'get_address_withdrawals',
+  displayName: 'Get Address Withdrawals',
+  description: 'Get list of withdrawals for an address',
+  audience: 'both',
+  aiMetadata: { description: 'List beacon-chain (staking) withdrawals credited to an address. Choose this to inspect validator-staking payout history for an account; returns empty for addresses that received no withdrawals. Read-only lookup on eth.blockscout.com; requires a 0x address hash.', idempotent: true },
+  // category: 'Addresses',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Address Hash',
+      description: 'Hash of the address to fetch withdrawals for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/addresses/${context.propsValue.addressHash}/withdrawals`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/addresses/addresses.ts

@@ -0,0 +1,22 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getAddresses = createAction({
+  name: 'get_addresses',
+  displayName: 'Get Addresses',
+  description: 'Get list of native coin holders',
+  audience: 'both',
+  aiMetadata: { description: 'List the top native-coin (ETH) holding addresses on the chain, ordered by balance. Pick this to discover or rank wealthy accounts; it takes no input and does not target a specific address (use Get Address by Hash for a single account). Read-only lookup on eth.blockscout.com.', idempotent: true },
+  // category: 'Addresses',
+  props: {},
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/addresses`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/addresses/index.ts

@@ -0,0 +1,13 @@
+export * from './addresses';
+export * from './address-by-hash';
+export * from './address-counters';
+export * from './address-transactions';
+export * from './address-token-transfers';
+export * from './address-internal-transactions';
+export * from './address-logs';
+export * from './address-blocks-validated';
+export * from './address-token-balances';
+export * from './address-tokens';
+export * from './address-withdrawals';
+export * from './address-coin-balance-history';
+export * from './address-coin-balance-history-by-day';

package/src/lib/actions/blocks/block-by-hash.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getBlockByHash = createAction({
+  name: 'get_block_by_hash',
+  displayName: 'Get Block by Hash or Number',
+  description: 'Get block info by its hash or block number',
+  audience: 'both',
+  aiMetadata: { description: 'Look up a single Ethereum block by either its hash or its block number and return its details (miner, timestamp, gas, transaction count). Read-only; accepts both identifier forms. Use this when you know which block you want; to browse recent blocks without an identifier use Get Blocks.', idempotent: true },
+  // category: 'Blocks',
+  props: {
+    blockIdentifier: Property.ShortText({
+      displayName: 'Block Hash or Number',
+      description: 'Block hash or block number to fetch',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/blocks/${context.propsValue.blockIdentifier}`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/blocks/block-transactions.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getBlockTransactions = createAction({
+  name: 'get_block_transactions',
+  displayName: 'Get Block Transactions',
+  description: 'Get list of transactions for a specific block',
+  audience: 'both',
+  aiMetadata: { description: 'List the transactions contained in one Ethereum block, identified by its hash or number. Read-only. Use this to scope transactions to a single block; for chain-wide recent transactions use the Transactions Get Transactions action, and for that block\'s staking withdrawals use Get Block Withdrawals.', idempotent: true },
+  // category: 'Blocks',
+  props: {
+    blockIdentifier: Property.ShortText({
+      displayName: 'Block Hash or Number',
+      description: 'Block hash or block number to fetch transactions for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/blocks/${context.propsValue.blockIdentifier}/transactions`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/blocks/block-withdrawals.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getBlockWithdrawals = createAction({
+  name: 'get_block_withdrawals',
+  displayName: 'Get Block Withdrawals',
+  description: 'Get list of withdrawals for a specific block',
+  audience: 'both',
+  aiMetadata: { description: 'List the validator (beacon-chain) staking withdrawals included in one Ethereum block, identified by its hash or number. Read-only. Use this for post-Merge withdrawal data of a specific block; for the regular transactions in that block use Get Block Transactions instead.', idempotent: true },
+  // category: 'Blocks',
+  props: {
+    blockIdentifier: Property.ShortText({
+      displayName: 'Block Hash or Number',
+      description: 'Block hash or block number to fetch withdrawals for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/blocks/${context.propsValue.blockIdentifier}/withdrawals`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/blocks/blocks.ts

@@ -0,0 +1,22 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getBlocks = createAction({
+  name: 'get_blocks',
+  displayName: 'Get Blocks',
+  description: 'Get list of blocks',
+  audience: 'both',
+  aiMetadata: { description: 'List recent Ethereum blocks across the chain (newest first), takes no inputs. Read-only. Use this for chain-wide block browsing; to fetch one specific block use Get Block by Hash or Number.', idempotent: true },
+  // category: 'Blocks',
+  props: {},
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/blocks`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/blocks/index.ts

@@ -0,0 +1,5 @@
+export * from './blocks';
+export * from './main-page-blocks';
+export * from './block-by-hash';
+export * from './block-transactions';
+export * from './block-withdrawals';

package/src/lib/actions/blocks/main-page-blocks.ts

@@ -0,0 +1,22 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getMainPageBlocks = createAction({
+  name: 'get_main_page_blocks',
+  displayName: 'Get Main Page Blocks',
+  description: 'Get blocks for main page display',
+  audience: 'both',
+  aiMetadata: { description: 'Get the short list of latest blocks shown on the Blockscout explorer home page, takes no inputs. Read-only. Use this for a quick at-a-glance feed of the newest blocks; for a fuller paginated block list use Get Blocks.', idempotent: true },
+  // category: 'Blocks',
+  props: {},
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/main-page/blocks`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/index.ts

@@ -0,0 +1,6 @@
+export * from './search';
+export * from './search-redirect';
+export * from './blocks';
+export * from './transactions';
+export * from './addresses';
+export * from './tokens';

package/src/lib/actions/search/index.ts

@@ -0,0 +1 @@
+export * from './search';

package/src/lib/actions/search/search.ts

@@ -0,0 +1,31 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const search = createAction({
+  name: 'search',
+  displayName: 'Search',
+  description: 'Search for addresses, transactions, blocks, or tokens',
+  audience: 'both',
+  aiMetadata: { description: 'Run a free-text search across the chain for addresses, transactions, blocks, and tokens, returning ranked matches. Pick this when you have a name, symbol, or partial identifier and need to resolve it to an entity; use the dedicated by-hash lookups when you already hold an exact hash. Read-only lookup on eth.blockscout.com.', idempotent: true },
+  // category: 'Search',
+  props: {
+    query: Property.ShortText({
+      displayName: 'Search Query',
+      description: 'Search query for addresses, transactions, blocks, or tokens',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/search`,
+      queryParams: {
+        q: context.propsValue['query']
+      },
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/search-redirect/check-redirect.ts

@@ -0,0 +1,31 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const checkRedirect = createAction({
+  name: 'check_redirect',
+  displayName: 'Check Search Redirect',
+  description: 'Check if a search query should redirect to a specific resource',
+  audience: 'both',
+  aiMetadata: { description: 'Check whether a search query maps unambiguously to a single resource (address, transaction, block, or token) and should redirect straight to it. Pick this to disambiguate an exact identifier into one entity rather than browsing ranked results from Search. Read-only lookup on eth.blockscout.com.', idempotent: true },
+  // category: 'Search',
+  props: {
+    query: Property.ShortText({
+      displayName: 'Search Query',
+      description: 'Search query to check for redirect',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/search/check-redirect`,
+      queryParams: {
+        q: context.propsValue.query
+      },
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/search-redirect/index.ts

@@ -0,0 +1 @@
+export * from './check-redirect';

package/src/lib/actions/tokens/index.ts

@@ -0,0 +1,6 @@
+export * from './tokens';
+export * from './token-by-address';
+export * from './token-transfers';
+export * from './token-holders';
+export * from './token-counters';
+export * from './token-instances';

package/src/lib/actions/tokens/token-by-address.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getTokenByAddress = createAction({
+  name: 'get_token_by_address',
+  displayName: 'Get Token by Address',
+  description: 'Get token info by its contract address',
+  audience: 'both',
+  aiMetadata: { description: 'Look up the metadata for a single token by its contract address (name, symbol, decimals, type, total supply). Read-only. Use this when you have a specific token contract address; to discover tokens without an address use Get Tokens, and for holder or transfer detail use the dedicated token actions.', idempotent: true },
+  // category: 'Tokens',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Token Address',
+      description: 'Contract address of the token to fetch info for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/tokens/${context.propsValue.addressHash}`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/tokens/token-counters.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getTokenCounters = createAction({
+  name: 'get_token_counters',
+  displayName: 'Get Token Counters',
+  description: 'Get token counters (holders count, transfers count, etc.)',
+  audience: 'both',
+  aiMetadata: { description: 'Get aggregate counts for one token by its contract address, such as total number of holders and total transfers. Read-only. Use this when you just need the summary numbers; to enumerate the actual holders or transfers use Get Token Holders or Get Token Transfers instead.', idempotent: true },
+  // category: 'Tokens',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Token Address',
+      description: 'Contract address of the token to fetch counters for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/tokens/${context.propsValue.addressHash}/counters`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/tokens/token-holders.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getTokenHolders = createAction({
+  name: 'get_token_holders',
+  displayName: 'Get Token Holders',
+  description: 'Get list of token holders',
+  audience: 'both',
+  aiMetadata: { description: 'List the addresses holding one token, identified by its contract address, with their balances (largest holders first). Read-only. Use this to see who owns a token; for just the total holder count use Get Token Counters, and for NFT item IDs use Get Token Instances.', idempotent: true },
+  // category: 'Tokens',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Token Address',
+      description: 'Contract address of the token to fetch holders for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/tokens/${context.propsValue.addressHash}/holders`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/tokens/token-instances.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getTokenInstances = createAction({
+  name: 'get_token_instances',
+  displayName: 'Get Token Instances',
+  description: 'Get list of token instances (NFTs)',
+  audience: 'both',
+  aiMetadata: { description: 'List the individual NFT instances (token IDs) minted under one NFT contract, identified by its address. Read-only and only meaningful for ERC-721/1155 collections. Use this to enumerate items in a collection; for fungible token holders use Get Token Holders and for general token info use Get Token by Address.', idempotent: true },
+  // category: 'Tokens',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Token Address',
+      description: 'Contract address of the token to fetch instances for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/tokens/${context.propsValue.addressHash}/instances`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/tokens/token-transfers.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getTokenTransfers = createAction({
+  name: 'get_token_transfers',
+  displayName: 'Get Token Transfers',
+  description: 'Get list of token transfers',
+  audience: 'both',
+  aiMetadata: { description: 'List recent transfers of one token, identified by its contract address, across all holders (newest first). Read-only. Use this to track movement of a specific token over time; for the token transfers inside a single transaction use the Transactions Get Transaction Token Transfers action instead.', idempotent: true },
+  // category: 'Tokens',
+  props: {
+    addressHash: Property.ShortText({
+      displayName: 'Token Address',
+      description: 'Contract address of the token to fetch transfers for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/tokens/${context.propsValue.addressHash}/transfers`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/tokens/tokens.ts

@@ -0,0 +1,23 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getTokens = createAction({
+  name: 'get_tokens',
+  displayName: 'Get Tokens',
+  description: 'Get list of tokens',
+  audience: 'both',
+  aiMetadata: { description: 'List tokens tracked on the chain (ERC-20/721/1155), takes no inputs. Read-only. Use this to browse or discover tokens when you do not have a specific contract address; once you have an address use Get Token by Address for its details.', idempotent: true },
+
+  // category: 'Tokens',
+  props: {},
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/tokens`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/transactions/index.ts

@@ -0,0 +1,9 @@
+export * from './transactions';
+export * from './main-page-transactions';
+export * from './transaction-by-hash';
+export * from './transaction-token-transfers';
+export * from './transaction-internal-transactions';
+export * from './transaction-logs';
+export * from './transaction-raw-trace';
+export * from './transaction-state-changes';
+export * from './transaction-summary';

package/src/lib/actions/transactions/main-page-transactions.ts

@@ -0,0 +1,22 @@
+import { createAction } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getMainPageTransactions = createAction({
+  name: 'get_main_page_transactions',
+  displayName: 'Get Main Page Transactions',
+  description: 'Get transactions for main page display',
+  audience: 'both',
+  aiMetadata: { description: 'Get the short list of latest Ethereum transactions shown on the Blockscout explorer home page. Read-only and takes no inputs. Use this for a quick at-a-glance feed of the most recent activity; for a fuller paginated transaction list use Get Transactions instead.', idempotent: true },
+  // category: 'Transactions',
+  props: {},
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/main-page/transactions`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});

package/src/lib/actions/transactions/transaction-by-hash.ts

@@ -0,0 +1,28 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+export const getTransactionByHash = createAction({
+  name: 'get_transaction_by_hash',
+  displayName: 'Get Transaction by Hash',
+  description: 'Get transaction details by its hash',
+  audience: 'both',
+  aiMetadata: { description: 'Look up a single Ethereum transaction by its full hash and return its core details (status, value, gas, from/to, block). Read-only. Use this when you have a specific transaction hash; for the related transfers, logs, internal calls, or state changes of that same transaction use the dedicated per-transaction actions instead.', idempotent: true },
+  // category: 'Transactions',
+  props: {
+    transactionHash: Property.ShortText({
+      displayName: 'Transaction Hash',
+      description: 'Hash of the transaction to fetch details for',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://eth.blockscout.com/api/v2/transactions/${context.propsValue.transactionHash}`,
+    });
+    if (response.status !== 200) {
+      throw new Error(`Blockscout API request failed with status ${response.status}`);
+    }
+    return response.body;
+  },
+});