Introduction

Today, we will discuss an essential contract for smart contract developers called the payment splitter contract. But what is it, what is it used for, and why should you care? Let's explore a scenario to understand its significance.

imagine you are part of a team of skilled smart contract developers working on an ERC721 contract (NFTs) that incorporates a royalty functionality. However, you encounter a challenge: how can you streamline and automate the process of distributing these royalties amongst the dev team?

This is where the payment splitter contract comes into play. Essentially, it is a tool that automates the distribution of proceeds among different parties involved.

As a smart contract developer, using a payment splitter contract saves you time and effort by streamlining royalty distribution. Instead of manually calculating and distributing payments, this automated solution does it for you.

What is payment splitting?

To fully grasp the concept of a payment splitter contract, let's first break down what payment splitting means.

Payment splitting is the act of dividing a single payment or transaction into multiple parts and assigning them to different recipients or accounts. This is especially useful when there are several parties involved in a transaction who need to receive their respective shares of the payment.

To help you grasp the concept of payment splitting, let's walk through an example. Imagine you have an online business that sells products and a customer buys something worth $100. But here's the catch - you have agreements with two other parties, let's call them your supplier and another vendor. Both of them are entitled to receive a portion of this payment.

In this scenario, using a payment splitter allows you to divide the $100 payment into three parts: one for your account, one for the supplier's account, and one for the other vendor's account. This way, everyone gets their fair share of the transaction.

The process of payment splitting usually involves using a platform or service that helps with dividing and distributing funds. These platforms may provide APIs (Application Programming Interfaces) or software integrations that automate this process.

Here's how it works:

1. The customer makes a $100 payment through your online store.

2. The payment processing system recognizes that this transaction needs to be split.

3. The system divides the $100 into three parts: $70 for your account, $20 for the supplier's account, and $10 for the other vendor's account.

4. The system then transfers each portion to its designated account.

5. All parties involved receive their allocated funds without any manual intervention required.

Payment splitting can be particularly helpful in various scenarios, such as marketplace platforms like Etsy or eBay where multiple sellers are involved in a single transaction; sharing economy platforms like Uber or Airbnb where payments need to be distributed among service providers; or even in traditional business setups with joint ventures or profit-sharing agreements.

By automating the process of dividing payments, payment splitting reduces the chances of manual errors and administrative burdens. It ensures accurate and timely distribution of funds, allowing businesses to streamline their operations and maintain transparency with all parties involved.

Overall, payment splitting simplifies the task of sharing funds among multiple recipients, making it easier for beginners and businesses alike to manage complex financial transactions.

Overview of the key features and functionality of a payment splitter contract

Let's take a look at a quick overview of the key features and functionalities of a payment splitter contract, I will be covering the key features and functionalities of payment splitter contracts, including parties involved, allocation ratios, automatic distribution, real-time updates, flexibility in recipient wallets, gas efficiency, security and transparency, and contract customization.

1. Parties Involved: A payment splitter contract involves three main parties: the sender (the person initiating the payment), recipients (those who will receive a portion of the funds), and the contract itself (an intermediary responsible for distributing the funds).

2. Allocation Ratios: One important feature of payment splitter contracts is the ability to define allocation ratios for each recipient. These ratios determine how much of the total payment each recipient will receive. For example, if there are three recipients with allocation ratios set at 50%, 30%, and 20%, respectively, they will receive 50%, 30%, and 20% of the total payment amount.

3. Automatic Distribution: Once the sender transfers funds to the payment splitter contract, it automatically splits and distributes them according to the defined allocation ratios. This eliminates manual calculations and ensures accurate distribution without any additional effort from the sender.

4. Real-Time Updates: Payment splitter contracts provide real-time updates on fund distribution. Recipients can track their received amounts instantly through their associated wallet addresses or by accessing transaction history on a blockchain explorer.

5. Flexibility in Recipients' Wallets: Recipients can choose their preferred wallet addresses for receiving payments from the splitter contract. This allows them to use wallets compatible with different cryptocurrencies or platforms, making it convenient for participants with diverse preferences.

6. Gas Efficiency: To ensure efficiency in gas costs (transaction fees), most payment splitter contracts utilize gas optimizations during fund distribution processes. These optimizations minimize costs associated with executing the contract on the blockchain.

7. Security and Transparency: Payment splitter contracts are built on a blockchain, ensuring security and transparency. All transactions and fund distributions are recorded on the blockchain, making them publicly verifiable. This provides an additional layer of trust and accountability.

8. Contract Customization: Advanced payment splitter contracts may offer customization options, allowing users to define additional parameters such as time-based distributions or conditional payments based on specific events or conditions.

Breaking down the Payment Splitter Contract

Let's recap, payment splitter contracts are a smart contract feature that automatically splits payments among multiple recipients. In this section, we will explore the technical aspects of payment splitter contracts, including their structure, inheritance hierarchy, and key functions.

To comprehend payment splitter contracts, it is beneficial to have a clear understanding of how inheritance works in smart contracts. Inheritance essentially enables a contract to acquire the attributes and functionalities of another contract, establishing a hierarchical connection between them.

In the case of payment splitter contracts, they typically inherit from a pre-existing smart contract called Ownable. This contract provides basic functionality for managing ownership and access control. By inheriting from Ownable, payment splitter contracts can utilize these functionalities without having to redefine them.

Key Components of Payment Splitter Contracts:

1. State Variables: Payment splitter contracts use state variables to store data within the contract. For example, there might be a state variable called "beneficiaries" that represents an array of addresses where payments will be split.

2. Constructor: The constructor is a special function that is executed only once during deployment. It initializes the state variables of the payment splitter contract. Typically, a payment splitter constructor takes an array of beneficiary addresses as input and stores them in the "beneficiaries" variable.

3. Payable Function: The payable function allows payments to be sent to the contract. When someone sends Ether or other applicable tokens to this function, it automatically splits the payment among all beneficiaries according to predefined rules.

4. Internal Functions: Internal functions are defined within the payment splitter contract but cannot be directly accessed by external users or contracts. They provide internal logic for splitting payments among beneficiaries based on specific rules or algorithms.

By leveraging inheritance and implementing these components within a payment splitter contract, developers can create an intuitive solution that effortlessly distributes payments without manual intervention.

Note: Payment splitter contracts are commonly used in situations where funds need to be divided among multiple parties, such as crowdfunding campaigns or shared expenses among a group.

key functions

Let's take a look at some key functions in a payment splitter contract, we will be focusing on the setShares and release functions.

In a payment splitter contract, the key functions setShares and release serves different purposes in managing the distribution of funds to multiple recipients. Let's break down each function and its functionalities in a beginner-friendly manner:

1. setShares: This function allows the contract owner to specify the shares or proportions of funds that each recipient is entitled to receive. For example, if there are three recipients and the owner wants them to receive 30%, 40%, and 30% of the total funds respectively, they can use this function to set these percentages. The purpose of this function is to define how much each recipient will receive when funds are released.

2. release: The release function is used by recipients to claim their share of the funds allocated to them. Once the contract owner has set the shares using setShares, recipients can call this function individually whenever they want to withdraw their respective portions. The purpose of this function is to distribute funds from the contract balance to each recipient based on their allocated shares.

   Overall, these key functions work together in enabling efficient management and distribution of funds within a payment splitter contract. The combination of setting shares and releasing funds ensures fairness and transparency in dividing payments among multiple parties involved in a particular transaction or project.

Deploying a Payment Splitter Contract

In this section, I will guide you through the process of deploying a payment splitter contract using Hardhat. We will go step by step, starting from installing Hardhat, initializing a new project, installing the OpenZeppelin Contracts package, writing your contract code that inherits from the Payment Splitter contract, configuring Hardhat, and finally deploying your contract.

Step 1: Install Hardhat

Before we begin, ensure that you have Node.js installed on your machine. Next, open your command line interface and run the following command to install Hardhat globally:

npm install -g hardhat

Step 2: Create a New Project

Create a new directory for your project and navigate into it. Then, initialize a new Hardhat project by running the following command:

npx hardhat init

This command will create all the necessary files and folders for your project.

Step 3: Install OpenZeppelin Contracts

To use the Payment Splitter contract from OpenZeppelin, you need to install the OpenZeppelin Contracts package. In your project directory, run the following command:

npm install @openzeppelin/contracts

Step 4: Write Your Contract Code

Create a new Solidity file (e.g., PaymentSplitter.sol) in the contracts directory of your project. In this file, write your contract code that inherits from the Payment Splitter contract. Here's an example:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/payment/PaymentSplitter.sol";

contract MyPaymentSplitter is PaymentSplitter {
    constructor(address[] memory payees, uint256[] memory shares)
        PaymentSplitter(payees, shares)
    {}
}

This example code creates a new contract called MyPaymentSplitter that inherits from PaymentSplitter.

Step 5: Configure Hardhat

Open the hardhat.config.js file in your project directory and modify it as follows:

module.exports = {
  solidity: "0.8.0",
  networks: {
    hardhat: {},
    // Add other network configurations here
  },
};

This configuration file specifies the Solidity version and defines the network settings for Hardhat.

Step 6: Deploy Your Contract

Create a new deployment script in the scripts directory of your project (e.g., deploy.js). In this script, write the code to deploy your contract. Here's an example:

const { ethers } = require("hardhat");

async function main() {
  try {
    const MyPaymentSplitter = await ethers.getContractFactory("MyPaymentSplitter");
    const paymentSplitter = await MyPaymentSplitter.deploy(
      ["0xAddress1", "0xAddress2"], // Replace with actual addresses
      [50, 50] // Replace with actual shares
    );

    await paymentSplitter.deployed();

    console.log("Payment Splitter deployed to:", paymentSplitter.address);
    process.exit(0);
  } catch (error) {
    console.error(error);
    process.exit(1);
  }
}

main();

Make sure to replace "0xAddress1" and "0xAddress2" with actual Ethereum addresses for payees, and [50, 50] with actual shares corresponding to each payee.

Step 7: Run the Deployment Script Open your command line interface and run the following command to deploy your contract:

npx hardhat run scripts/deploy.js --network

This command will execute the deployment script using Hardhat on the specified network (in this case, Hardhat's built-in local network).

That's it! Your contract should now be deployed to the Ethereum-compatible blockchain using Hardhat. You can access it through its contract address.

For further explanation, please visit the OpenZeppelin documentation