TLDR:

• You’ll build a trust fund contract that can accept deposits from anyone, but only the owner can withdraw.
• Ownership can be transferred to another address, making it useful for simple DeFi scenarios.
• You’ll rely on Chainstack for an Ethereum Sepolia node, and Remix + MetaMask for contract compilation and deployment.
• By the end, you’ll have a fully functional trust fund contract deployed to Sepolia and ready to receive or withdraw Ether.

​

Main article

Unlike legacy finance systems, where you need to rely on a well-established third party, you can build your own financial instrument on Ethereum.

The objective of this tutorial is to show how easy it is to build and run your own instance of a simple decentralized finance example, or DeFi.

In this tutorial, you will:

• Create a basic Trust Fund account smart contract with the following interaction options:

  • Fund the account from any Ethereum address
  • Withdraw all funds from the account only from the account owner’s address
  • Withdraw partial funds from the account only from the account owner’s address
  • Transfer the account ownership to any Ethereum address

• Compile the smart contract with Remix IDE.

• Deploy the smart contract to the Ethereum Sepolia testnet through a Chainstack node.

• Interact with the smart contract through Remix IDE and a Chainstack node.

​

Prerequisites

• Chainstack account to deploy an Ethereum node.
• Remix IDE to compile the contract and deploy it through MetaMask.
• MetaMask to deploy the contract through the Chainstack node and interact with the contract.

​

Overview

To get from zero to a deployed Trust Fund account on the Ethereum Sepolia testnet, do the following:

​

Step-by-step

​

Create a public chain project

See Create a project.

​

Join the Ethereum Sepolia testnet

See Join a public network.

​

Get your Ethereum node access and credentials

See View node access and credentials.

​

Set up MetaMask

See Ethereum tooling: MetaMask.

Having set up your MetaMask to interact through a Chainstack node, your Remix IDE will also interact with the network through a Chainstack node.

Create at least two accounts in MetaMask. You need two accounts to transfer the contract ownership from one to another.

In your MetaMask, fund each account with Sepolia ether Chainstack’s Sepolia faucet.

​

Create and compile the Trust Fund smart contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @title TransferableTrustFundAccount
 * @dev A trust fund account that can be transferred to a new owner
 */
contract TransferableTrustFundAccount {
    address payable public owner; // The current owner of the contract

    /**
     * @dev Modifier to restrict access to owner-only functions
     */
    modifier onlyOwner() {
        require(msg.sender == owner, "Caller is not the owner");
        _;
    }

    /**
     * @dev Initializes the contract by setting the initial owner
     */
    constructor() {
        owner = payable(msg.sender);
    }

    /**
     * @dev Withdraws the entire contract balance to the owner
     */
    function withdrawAll() public onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "Insufficient funds");
        owner.transfer(balance);
    }

    /**
     * @dev Withdraws a specified amount to the owner
     * @param amount The amount to withdraw
     */
    function withdrawAmount(uint256 amount) public onlyOwner {
        uint256 balance = address(this).balance;
        require(balance >= amount, "Insufficient funds");
        owner.transfer(amount);
    }

    /**
     * @dev Transfers ownership of the contract to a new account
     * @param newOwner The address of the new owner
     */
    function transferAccount(address payable newOwner) public onlyOwner {
        require(newOwner != address(0), "Invalid address");
        owner = newOwner;
    }

    /**
     * @dev Gets the current balance of the contract
     * @return The current balance of the contract
     */
    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

    /**
     * @dev Gets the current owner of the contract
     * @return The address of the current owner
     */
    function getOwner() public view returns (address) {
        return owner;
    }

    /**
     * @dev Fallback function to accept incoming transfers
     */
    receive() external payable {}
}

​

Set up Remix IDE to work through your Chainstack node

On the left pane, click Deploy and switch to Injected Provider - Metamask:

This will engage your MetaMask and interact with the network through the Chainstack node provided in MetaMask.

​

Deploy the Trust Fund smart contract

On the left pane, click Deploy & run transactions > Deploy:

This will engage your MetaMask to deploy the contract to the Ethereum Sepolia testnet through your currently selected MetaMask account. Click Confirm in the MetaMask modal.

​

Interact with the Trust Fund smart contract

Once the contract is deployed, fund the contract:

1. Copy the contract address under Deployed Contracts.
2. Open your MetaMask and send Sepolia ether to the copied contract address.

Now that your contract is funded, you can interact with it.

Expand the contract under Deployed Contracts:

• withdrawAmount — enter any amount that is less than the current contract balance to withdraw partial funds.
• withdrawAll — click to withdraw all funds from the contract.
• transferAccount — enter any Ethereum address to transfer the contract ownership. For this example, enter the address of your second account in MetaMask.
• getBalance — click to display the current ether balance in the smart contract; the balance is shown in Wei.
• getOwner — click to display the address currently owning the Trust fund smart contract.

​

About the author

Ake

Director of Developer Experience @ Chainstack

Talk to me all things Web3

20 years in technology | 8+ years in Web3 full time years experience

Trusted advisor helping developers navigate the complexities of blockchain infrastructure