Ethereum: Trust fund account with Remix

• 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

• 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

1. With Chainstack, create a public chain project .
2. With Chainstack, join the Ethereum Sepolia testnet.
3. With Chainstack, access your Ethereum node credentials.
4. Set up your MetaMask to work through a Chainstack node.
5. With Remix IDE, create and compile the Trust Fund smart contract.
6. Set up your Remix IDE to work through a Chainstack node.
7. With Remix IDE, deploy the contract to the Ethereum Sepolia testnet.
8. With Remix IDE, interact with the contract on the Ethereum Sepolia testnet.

​

Step-by-step

​

Create a public chain project

​

Join the Ethereum Sepolia testnet

​

Get your Ethereum node access and credentials

​

Set up MetaMask

​

Create and compile the Trust Fund smart contract

1. Open Remix IDE.
2. On the home page, click Environments > Solidity.
3. On the left pane, click File explorers > +.
4. In the modal, give any name to your contract. For example, transferableTrustFund.sol.
5. Put in the contract code:
   transferableTrustFund.sol

   Copy

   // 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 {}
   }
   

   This is your Trust Fund account smart contract:
   • The contract belongs to the Ethereum account that deploys the contract through:
     transferableTrustFund.sol

     Copy

     contract TransferableTrustFundAccount {
       address payable public owner;
       ...
     }
     

   • The onlyOwner modifier is used to restrict access to certain functions in the smart contract to only the owner of the contract. A modifier is like a wrapper that can be applied to a function, and it modifies the behavior of the function in some way:
     transferableTrustFund.sol

     Copy

         modifier onlyOwner() {
           require(msg.sender == owner, "Caller is not the owner");
           _;
       }
     

   • Only the contract owner can withdraw all funds from the contract through:
     transferableTrustFund.sol

     Copy

     function withdrawAll() public onlyOwner {
       uint256 balance = address(this).balance;
       require(balance > 0, "Insufficient funds");
       owner.transfer(balance);
       }
     

   • Only the contract owner can withdraw partial funds from the contract through:
     transferableTrustFund.sol

     Copy

     function withdrawAmount(uint256 amount) public onlyOwner {
       uint256 balance = address(this).balance;
       require(balance >= amount, "Insufficient funds");
       owner.transfer(amount);
       }
     

   • Anyone can deposit funds to the contract through:
     transferableTrustFund.sol

     Copy

     receive() external payable {}
     

   • Only the contract owner can transfer the contract ownership to any other Ethereum account through:
     transferableTrustFund.sol

     Copy

     function transferAccount(address payable newOwner) public onlyOwner {
       require(newOwner != address(0), "Invalid address");
       owner = newOwner;
     		}
     

   • Retrieve the current balance on the smart contract and the current owner with:
     transferableTrustFund.sol

     Copy

     function getBalance() public view returns (uint256) {
       return address(this).balance;
      }
     
     function getOwner() public view returns (address) {
       return owner;
      }
     

6. Compile the contract. On the left pane, click Solidity compiler > Compile:

​

Set up Remix IDE to work through your Chainstack node

​

Deploy the Trust Fund smart contract

​

Interact with the Trust Fund smart contract

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

• 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 Web320 years in technology | 8+ years in Web3 full time years experienceTrusted advisor helping developers navigate the complexities of blockchain infrastructure