Nodes in blockchain do not understand what smart contract is. Rather smart contract is a piece of code that can be written in Solidity or Serpent(any language which supports generating bytecode understand by EVM (Ethereum Virtual Machine))
You have to write a smart contract which can have some functions maintaining its own state variables. These smart contracts will have to be compiled resulting bytecodes. Then to deploy that smart contract, this bytecode will be sent to the chain as a part of transaction. This will create an instance of the contract in the chain and an account address like other user accounts. To deploy a smart contract is a transaction and it creates storage for the contract variables modifying the state of the blockchain, consequentially. To change/modify any state value of that smart contract, you need to make transaction (this will contain some code to execute) in the blockchain. So, making transaction in ethereum blockchain means either you are transferring ether (which is modifying account balance information in the blockchain) or deploying a smart contract or invoking a function of the deployed smart contract to change the state variables of the contract.
So steps to deploy smart contract:
- Write a smart contract
- Compile the smart contract
- Generate byte code through compiling
- Make a transaction to deploy the smart contract and send the transaction to any node in the network
- The transaction will be mined and added in a block by any node and will be received by other nodes
- Get contract address from that transaction's receipt
- Make transactions further to that contract address to invoke methods of that deployed smart contract
In ethereum, account balance is maintained by State trie of the blockchain. So when, you are deploying a smart contract, the bytecode passed as part of the transaction will be saved in the state trie as a part of the account created for the deployed contract. In fact, inside blocks, you will find the transactions, not the contracts. When, you will again make any transaction to invoke any function of the contract or just call any method of that contract to retrieve value of the variables, the code to execute in the EVM will be found from that state trie.
All nodes only understand that it is a transaction. It can contain some code (bytecode of the contract) to execute in the evm. It just executes them and changes the state in the blockchain. It has no idea of it. Either the transaction will be executed successfully or it will fail which will be reflected in the status field of the transaction receipt. So, nodes only execute those byte codes. If any logic written in the smart contract reverts the transaction, it will just revert the state. All nodes will just verify the state of the blockchain to be consistent after executing the transaction.
If your smart contract has syntax errors, it will not generate bytecode in the compiler. If your bytecode contains wrong opcodes unknown to the EVM, the transaction will get failed.
I don't know which type of verification of smart contract you are talking about.
Hope my explanation will help you to understand.