Here is a basic outline of a blockchain program

 :

1. Data structure: Define the basic data structure of a block, which includes a block header, block body, and block footer. The block header should contain metadata such as the block's unique identifier, timestamp, previous block's hash, and a nonce. The block body should contain the actual data that is being stored on the blockchain, and the block footer should contain a hash of the block header and block body.

2. Block creation: Create a function that generates a new block using the data provided by the user. This function should take the previous block's hash as input and calculate a new hash for the current block. This hash should be calculated using a hash function like SHA-256. The function should also include a "proof of work" mechanism that requires the user to solve a difficult mathematical problem in order to add a new block to the blockchain.

3. Chain validation: Create a function that checks the validity of the blockchain by verifying that each block in the chain is connected to the previous block and that the hash of each block is correct. This function should also check the validity of the "proof of work" algorithm used to create each block.

4. Transaction handling: Define functions to handle user transactions, including adding new transactions to the blockchain and verifying the authenticity of existing transactions.

Here's some pseudocode to give you an idea of how the program might be structured:

python
class Block:
    def __init__(self, data, previous_hash):
        self.timestamp = datetime.now()
        self.data = data
        self.previous_hash = previous_hash
        self.nonce = 0
        self.hash = self.calculate_hash()

    def calculate_hash(self):
        return sha256((str(self.timestamp) + str(self.data) + str(self.previous_hash) + str(self.nonce)).encode()).hexdigest()

    def mine_block(self, difficulty):
        while self.hash[0:difficulty] != '0' * difficulty:
            self.nonce += 1
            self.hash = self.calculate_hash()

        print("Block mined:", self.hash)

class Blockchain:
    def __init__(self):
        self.chain = [Block("Genesis Block", "0")]
        self.difficulty = 4

    def add_block(self, data):
        block = Block(data, self.chain[-1].hash)
        block.mine_block(self.difficulty)
        self.chain.append(block)

    def is_chain_valid(self):
        for i in range(1, len(self.chain)):
            current_block = self.chain[i]
            previous_block = self.chain[i - 1]

            if current_block.hash != current_block.calculate_hash():
                return False

            if current_block.previous_hash != previous_block.hash:
                return False

            if current_block.hash[0:self.difficulty] != '0' * self.difficulty:
                return False

        return True

# Example usage
my_blockchain = Blockchain()
my_blockchain.add_block("Transaction 1")
my_blockchain.add_block("Transaction 2")
my_blockchain.add_block("Transaction 3")
print(my_blockchain.is_chain_valid())

This is a simple implementation of a blockchain program in Python, but it should give you an idea of how a blockchain works and how it can be implemented in code.