Make your life easier by leveraging the power of the smart contracts ecosystem. You get more with less effort.
Smart Contract Ecosystem
Here are some examples of Ethereum based smart contracts that may be used in a performance art collaboration involving performers, choreographers, managers, investors, brand sponsors and an audience.
Pay Performer Upon Performance
This smart contract would allow performers, choreographers and managers to receive payment. The terms of the contract could be set in advance, and the payment would be automatically transferred from the investor accounts to the performance members’ accounts.
contract PerformancePaymentContract {
enum PayeeType { Performer, Choreographer, Manager }
address payable public investor;
address payable public performer;
address payable public choreographer;
address payable public manager;
uint256 public paymentAmount;
mapping(uint256 => uint256) public allocationPercentages;
uint256 public paymentDate;
bool public performanceProven;
event PaymentSent(address indexed payee, uint256 amount);
constructor(
address payable _investor,
address payable _performer,
address payable _choreographer,
address payable _manager,
uint256 _paymentAmount,
uint256[] memory _allocationPercentages,
uint256 _paymentDate
) {
require(_allocationPercentages.length == 3, "Invalid allocation percentages");
require(_allocationPercentages[0] + _allocationPercentages[1] + _allocationPercentages[2] == 100, "Allocation percentages should sum up to 100");
investor = _investor;
performer = _performer;
choreographer = _choreographer;
manager = _manager;
paymentAmount = _paymentAmount;
allocationPercentages[uint256(PayeeType.Performer)] = _allocationPercentages[0];
allocationPercentages[uint256(PayeeType.Choreographer)] = _allocationPercentages[1];
allocationPercentages[uint256(PayeeType.Manager)] = _allocationPercentages[2];
paymentDate = _paymentDate;
performanceProven = false;
}
function sendPayment() external {
require(msg.sender == investor, "Only investor can call this function");
require(performanceProven, "Performance not proven yet");
require(block.timestamp >= paymentDate, "Payment date not reached yet");
// Calculate payment amounts for each payee
uint256 performerPayment = paymentAmount * allocationPercentages[uint256(PayeeType.Performer)] / 100;
uint256 choreographerPayment = paymentAmount * allocationPercentages[uint256(PayeeType.Choreographer)] / 100;
uint256 managerPayment = paymentAmount * allocationPercentages[uint256(PayeeType.Manager)] / 100;
// Transfer payment to each payee
performer.transfer(performerPayment);
choreographer.transfer(choreographerPayment);
manager.transfer(managerPayment);
emit PaymentSent(performer, performerPayment);
emit PaymentSent(choreographer, choreographerPayment);
emit PaymentSent(manager, managerPayment);
}
function provePerformance() external {
require(msg.sender == performer || msg.sender == choreographer || msg.sender == manager, "Only performer, choreographer, or manager can call this function");
require(!performanceProven, "Performance already proven");
performanceProven = true;
}
function cancel() external {
require(msg.sender == investor, "Only investor can call this function");
require(!performanceProven, "Performance already proven");
// Transfer payment back to investor
investor.transfer(paymentAmount);
}
}Expand
Performance Investment Contract
This smart contract would allow investors to invest money in a performance. The contract would specify investment terms including fund allocation and distribution from revenue received.
contract PerformanceInvestmentContract {
struct Investor {
uint256 investedAmount;
uint256 returnInvestment;
bool active;
}
uint256 public investmentAmount;
uint256 public percentReturn;
uint256 public percentRevenueDistribution;
uint256[] public waterfallDistributionAllocation;
mapping(address => Investor) public investors;
uint256 public totalInvestedAmount;
bool public investmentClosed;
event InvestmentReceived(address indexed investor, uint256 amount);
event PaymentSent(address indexed investor, uint256 amount);
constructor(
uint256 _investmentAmount,
uint256[] memory _waterfallDistributionAllocation,
uint256 _percentReturn,
uint256 _percentRevenueDistribution
) {
require(_waterfallDistributionAllocation.length > 0, "Waterfall distribution allocation is empty");
require(_percentReturn <= 100, "Invalid percent return");
require(_percentRevenueDistribution <= 100, "Invalid percent revenue distribution");
require(_waterfallDistributionAllocation.length <= 3, "Invalid waterfall distribution allocation");
investmentAmount = _investmentAmount;
percentReturn = _percentReturn;
percentRevenueDistribution = _percentRevenueDistribution;
waterfallDistributionAllocation = _waterfallDistributionAllocation;
}
function invest() external payable {
require(!investmentClosed, "Investment closed");
require(msg.value == investmentAmount, "Incorrect investment amount");
require(investors[msg.sender].active == false, "Investor already active");
// Add investor to the list of active investors
investors[msg.sender] = Investor({
investedAmount: msg.value,
returnInvestment: 0,
active: true
});
// Update total invested amount
totalInvestedAmount += msg.value;
emit InvestmentReceived(msg.sender, msg.value);
}
function distributeRevenue(uint256 revenue) external {
require(investmentClosed, "Investment not closed yet");
// Calculate total return investment amount for all investors
uint256 totalReturnInvestment = 0;
for (uint256 i = 0; i < waterfallDistributionAllocation.length; i++) {
if (i == 0) {
totalReturnInvestment += revenue * waterfallDistributionAllocation[i] / 100;
} else {
totalReturnInvestment += (revenue - totalReturnInvestment) * waterfallDistributionAllocation[i] / 100;
}
}
// Distribute revenue to investors
for (uint256 i = 0; i < waterfallDistributionAllocation.length; i++) {
uint256 investorReturn = totalReturnInvestment * waterfallDistributionAllocation[i] / 100;
uint256 revenueDistribution = revenue * percentRevenueDistribution / 100;
uint256 investorPayment = investorReturn + revenueDistribution;
if (investorPayment > 0) {
address payable investorAddress = payable(address(uint160(i)));
investorAddress.transfer(investorPayment);
investors[investorAddress].returnInvestment += investorReturn;
emit PaymentSent(investorAddress, investorPayment);
}
}
}
function closeInvestment() external {
require(msg.sender == address(this).owner(), "Only contract owner can call this function");
require(!investmentClosed, "Investment already closed");
investmentClosed = true;
}
}Expand
Brand Sponsorship Contract
This smart contract would allow brands to sponsor performances by contributing a certain amount of money for every 1,000 views a performance receives. The contract would specify performance attributes and payment terms.
contract AudiencePayPerViewContract {
uint256 public paymentAmountPerSecond;
address public performer;
address public choreographer;
address public danceCompanyManager;
uint256 public totalPayment;
event PaymentReceived(address indexed payer, uint256 amount);
constructor(
uint256 _paymentAmountPerSecond,
address _performer,
address _choreographer,
address _danceCompanyManager
) {
paymentAmountPerSecond = _paymentAmountPerSecond;
performer = _performer;
choreographer = _choreographer;
danceCompanyManager = _danceCompanyManager;
totalPayment = 0;
}
function payPerView() external payable {
uint256 paymentAmount = paymentAmountPerSecond * msg.value;
// Split payment among performer, choreographer, and dance company manager
uint256 performerPayment = paymentAmount * 70 / 100;
uint256 choreographerPayment = paymentAmount * 20 / 100;
uint256 danceCompanyManagerPayment = paymentAmount * 10 / 100;
// Transfer payment to performer, choreographer, and dance company manager
address payable performerAddress = payable(address(uint160(performer)));
performerAddress.transfer(performerPayment);
address payable choreographerAddress = payable(address(uint160(choreographer)));
choreographerAddress.transfer(choreographerPayment);
address payable danceCompanyManagerAddress = payable(address(uint160(danceCompanyManager)));
danceCompanyManagerAddress.transfer(danceCompanyManagerPayment);
// Update total payment amount
totalPayment += paymentAmount;
emit PaymentReceived(msg.sender, paymentAmount);
}
}Expand
Audience Pay-Per-View Contract
This smart contract would enable viewers to pay a certain amount of money for every y seconds of watching a performance. The payment would be automatically transferred to performer, choreographer and dance company manager accounts.
contract AudiencePayPerViewContract {
uint256 public paymentAmountPerSecond;
address public performer;
address public choreographer;
address public danceCompanyManager;
uint256 public totalPayment;
event PaymentReceived(address indexed payer, uint256 amount);
constructor(
uint256 _paymentAmountPerSecond,
address _performer,
address _choreographer,
address _danceCompanyManager
) {
paymentAmountPerSecond = _paymentAmountPerSecond;
performer = _performer;
choreographer = _choreographer;
danceCompanyManager = _danceCompanyManager;
totalPayment = 0;
}
function payPerView() external payable {
uint256 paymentAmount = paymentAmountPerSecond * msg.value;
// Split payment among performer, choreographer, and dance company manager
uint256 performerPayment = paymentAmount * 70 / 100;
uint256 choreographerPayment = paymentAmount * 20 / 100;
uint256 danceCompanyManagerPayment = paymentAmount * 10 / 100;
// Transfer payment to performer, choreographer, and dance company manager
address payable performerAddress = payable(address(uint160(performer)));
performerAddress.transfer(performerPayment);
address payable choreographerAddress = payable(address(uint160(choreographer)));
choreographerAddress.transfer(choreographerPayment);
address payable danceCompanyManagerAddress = payable(address(uint160(danceCompanyManager)));
danceCompanyManagerAddress.transfer(danceCompanyManagerPayment);
// Update total payment amount
totalPayment += paymentAmount;
emit PaymentReceived(msg.sender, paymentAmount);
}
}Expand