Question: Specifically, if we look at any transaction on the Ethereum blockchain, is the TimeStamp based on when the transaction is generated (like when you click generate transaction on MEW), or is it based on when the transaction was successfully sent from whatever node generated that transaction?

Answer: 
When watching for events from web3, this is the format of the result you get when one is called:

```
{ address: '0x9c0ac1e0f0a8e0b01c7b652d5fbe094ddff48b81',
  blockNumber: 704227,
  transactionHash: '0x5887ba4e15d51e1cfddf626ecf416a0002085a1e0929fffe1f90ad69d5040081',
  transactionIndex: 0,
  blockHash: '0x5f485133ec662f556d88affccc18a358375de160178c6cf7cc0cec678d833a2a',
  logIndex: 0,
  removed: false,
  event: 'ExampleEvent',
  args: 
   { argOne: BigNumber { s: 1, e: 0, c: [Array] },
     argTwo: '0x374623456fa2' } }

```

So you can just get the TX from result.transactionHash

Event in contract:

```
event ExampleEvent(uint argOne, bytes32 argTwo)

```

Web3 code:

```
import exampleContractObject from 'path/to/ExampleContract.json'

ExampleContract = web3.eth.contract(exampleContractObject.abi);
contractInstance = ExampleContract.at('0x9c0ac1e0f0a8e0b01c7b652d5fbe094ddff48b81');
exampleEvent = contractInstance.ExampleEvent();

exampleEvent.watch((err, result) => {
  // Do something 
}

```

EDIT:

The Transfer event from ERC20 tokens would look like this:

```
{ address: '<contract_address>',
  blockNumber: <block_number>,
  transactionHash: '<transaction_hash>',
  transactionIndex: <tx_index_in_block,
  blockHash: '<block_hash>',
  logIndex: <log_index>,
  removed: <> ,
  event: 'Transfer',
  args: 
   { _from: <address>,
     _two: <address> ,
     _value: <uint256>} }

```
To accept tokens as payment all you need is an Ethereum account. Tokens can be sent to any address. To receive them, the people who own the tokens simply have to send them in a transaction on the network. I'm assuming that whoever deployed the contract to mint the tokens probably also created a front end user interface for accessing the transferTo() function in their token contract. 

So basically if you want to accept tokens as payment, all you have to do is post your Ethereum address and they can be sent. If you want to check how many tokens you have you can use etherscan.io or you can write up some code in Solidity that will check the balance. If the token is ERC20-compliant it will have a function in the contract that you should be able to access that will display tokens for any given address. To access that function you will need the contract ABI from the team who deployed it and then write a bit of Solidity code. 

If all you are interested in is accepting a token payment, then the person who has the tokens simply has to send them in a transaction to your account and you will have received them. 

The filter stuff would be if you're trying to watch the blockchain for any transfer of the tokens and keep a balance going on your local machine, or using Metamask or something. If you want to persist those balances in a local database, you'll probably have to write up a little bit of Solidity code and then get the contract address and ABI so access it.

Cheers