19 |
27 |
30 |
31 |
33 |
34 |
41 |
22 | 
23 |
24 |
25 | Token Subscriptions
26 |
27 | Recurring subscriptions on the Ethereum blockchain
28 | set it and forget it token transfers
29 |
30 |
31 |
33 |
34 |
35 |
40 | Disclaimer: We built this in a weekend!
36 | You should inspect our smart contract before using.
37 | 100% free and open source! Please contribute!
38 | UPDATE! Contract Audited!
39 |
38 |
43 |
48 |
49 | ETH Grants
40 |Recurring Ethereum funding via token subscriptions powered by meta transactions
41 |Create A Grant Fund A Grant
42 |Disclaimer: We built this in a weekend!
44 |You should inspect our smart contract before using.
45 |100% free and open source! Please contribute!
46 |UPDATE! Contract Audited!
47 |Congratulations, your contract is ready.
36 |You can now accept subscriptions!
37 |{contractAddress} {deployed}
38 |Follow the instructions below to share your subscription
39 |
40 |
49 | Add a link to your website:
41 |{"Subscribe Now"}
42 | Share Url:
43 |{url}
44 | QR Code:
45 |Embed a script on your website:
47 |{""}
48 | Your contract is being deployed
56 |(Make sure you confirm the metamask dialog to deploy your contract!)
57 | {contractAddress}
Follow the instructions below to share your subscription
59 |
60 |
69 | Add a link to your website:
61 |{"Subscribe Now"}
62 | Share Url:
63 |{url}
64 | QR Code:
65 |Embed a script on your website:
67 |{"\n"}
68 | {this.props.setMode("")}}>
70 | 
Previous
71 |
72 | Error: {error.message}
;
86 | } else if (!isLoaded) {
87 | return Loading...
;
88 | } else {
89 | let coins = []
90 | for(let i in items){
91 | console.log(items[i])
92 | coins.push({
93 | key: items[i].address,
94 | value: items[i].name,
95 | image:{
96 | avatar : true,
97 | src : items[i].imageUrl,
98 | },
99 | text: items[i].name
100 | })
101 | }
102 |
103 | return (
104 |
138 | );
139 | }
140 | }
141 | }
142 |
143 | export default App;*/
144 |
--------------------------------------------------------------------------------
/demosite/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
27 |
34 |
35 |
28 |
31 |
32 |
33 | WyoWaste
29 |First in the industry to offer waste disposal services for a Crypto Token.
30 |
36 |
49 |
97 |
98 |
99 |
--------------------------------------------------------------------------------
/src/components/subscriberApprove.js:
--------------------------------------------------------------------------------
1 | import React, { Component } from 'react';
2 | import { Address, Blockie, Scaler } from "dapparatus"
3 | import axios from 'axios'
4 | import Particles from '../particles.png';
5 | import Loader from "../loader.gif"
6 |
7 | let pollInterval
8 | let pollTime = 1777
9 |
10 | class SubscriberApprove extends Component {
11 | constructor(props) {
12 | super(props);
13 | this.state = {
14 | approved:0,
15 | approve:12,
16 | loading:false
17 | };
18 | }
19 | componentDidMount(){
20 | axios.get(this.props.backendUrl+"subscription/"+this.props.subscription, { crossdomain: true })
21 | .catch((err)=>{
22 | console.log("Error getting subscription",err)
23 | })
24 | .then(async (response)=>{
25 | console.log("subscription:",response.data)
26 | this.setState({subscription:response.data})
27 | //let subscriptionContract = this.props.customContractLoader("Subscription",this.props.contract)
28 | let tokenContract = this.props.customContractLoader("WasteCoin",response.data.parts[2])
29 | let decimals = await tokenContract.decimals().call()
30 | let foundToken
31 | for(let i = 0; i < this.props.coins.length; i++){
32 | if(tokenContract._address.toLowerCase() == this.props.coins[i].address.toLowerCase()){
33 | foundToken = this.props.coins[i]
34 | }
35 | }
36 | this.setState({token:foundToken,decimals:decimals,tokenContract:tokenContract})
37 | })
38 | pollInterval = setInterval(this.load.bind(this),pollTime)
39 | this.load()
40 | }
41 | componentWillUnmount(){
42 | clearInterval(pollInterval)
43 | }
44 | async load(){
45 | if(this.state.tokenContract){
46 | this.setState({
47 | balance:await this.state.tokenContract.balanceOf(this.props.account).call(),
48 | approved:await this.state.tokenContract.allowance(this.state.subscription.parts[0],this.state.subscription.subscriptionContract).call()
49 | })
50 | }
51 | }
52 | handleInput(e){
53 | let update = {}
54 | update[e.target.name] = e.target.value
55 | this.setState(update)
56 | }
57 | render() {
58 | let {web3,tx} = this.props
59 | if(!this.state.subscription){
60 | return (
61 |
37 |
42 |
38 |
41 | Commercial
39 |Waste Removal for your Business
40 |
43 |
48 |
44 |
47 | Residentail
45 |Waste Removal for your Home
46 |Approve Max Subscription Limit:
110 |Subscription: {this.state.subscription.subscriptionHash}
111 |
112 | {tokenAmount+gasPrice} 
{this.state.token.name}
113 |
114 |
115 | From to
122 |
123 |
124 | Recurring every {periodSeconds}s
125 |
126 |
127 | Token Balance: {this.state.balance/(10**this.state.decimals)}
128 |
129 |
130 | Approved Tokens: {this.state.approved/(10**this.state.decimals)}
131 |
132 |
133 | {loading}
136 |
150 |
151 | Subscriptions Parameters
102 |
103 |
104 |
110 |
111 |
112 |
125 |
126 |
127 |
128 |
138 |
139 |
140 |
143 |
144 |
145 |
146 |
149 |
150 |
155 |
156 | {this.props.setMode("")}}>
157 | Previous
158 |
159 | 
';
4 |
5 | var button = '';
6 |
7 | // create container
8 | buttoncontainer = document.createElement('div');
9 | buttoncontainer.id = 'coinsubscriptionbuttoncont';
10 | document.body.insertAdjacentElement('afterbegin', buttoncontainer);
11 | document.getElementById("coinsubscriptionbuttoncont").innerHTML = button;
12 |
13 | function getParams() {
14 | var script = document.getElementById("coinsubscription");
15 | var scriptsrc = script.src;
16 | var urlstring = scriptsrc.substring( scriptsrc.indexOf('?') + 1 );
17 | return urlstring.replace('contract=', '');
18 | }
19 |
20 | function openCoinSubscription() {
21 | window.location = 'https://tokensubscription.com/'+getParams();
22 | }
23 |
--------------------------------------------------------------------------------
/grants/src/App.css:
--------------------------------------------------------------------------------
1 | html, body, #root, .wrapper {
2 | height: 100%;
3 | }
4 | body {
5 | font-family: 'Roboto', sans-serif;
6 | color:#fff;
7 | font-size:18px;
8 | background-color: #162129;
9 | background-image: -webkit-linear-gradient(120deg, #162129 50%, #0f171c 25%);
10 | min-height: 500px;
11 | background-image: url(assets/img/bkg.jpg);
12 | background-position: top center;
13 | background-repeat: no-repeat;
14 | background-attachment: fixed;
15 | background-size: cover;
16 | background-color: #999;
17 | }
18 | a {
19 | color: #5396fd;
20 | }
21 | a:hover,
22 | a:focus {
23 | color: #6255d8;
24 | text-decoration: none;
25 | }
26 |
27 | hr {
28 | margin-top: 2rem;
29 | margin-bottom: 2rem;
30 | border-top: 1px solid rgba(255,255,255,0.4)
31 | }
32 |
33 | .wrapper::after {
34 | content: "";
35 | background: url('assets/img/particles.png') center 80% no-repeat;
36 | opacity: 0.6;
37 | top: 0;
38 | left: 0;
39 | bottom: 0;
40 | right: 0;
41 | position: absolute;
42 | z-index: -1;
43 | }
44 |
45 | .nav {
46 | clear: both;
47 | padding: 5px 15px;
48 | margin: 0 0 20px;
49 | list-style: none;
50 | text-align: center;
51 | font-size: 15px;
52 | background: rgba(0,0,0,0.3);
53 | }
54 | .nav li {
55 | display: inline-block;
56 | }
57 | .nav a {
58 | display: inline-block;
59 | padding: 5px 10px;
60 | color: #fff;
61 | }
62 | .nav a:hover, .nav a:focus {
63 | color: #ccc;
64 | }
65 |
66 | .is-home .nav {
67 | display: none;
68 | }
69 |
70 | button {
71 | display: inline-block;
72 | font-weight: 400;
73 | text-align: center;
74 | white-space: nowrap;
75 | vertical-align: middle;
76 | -webkit-user-select: none;
77 | -moz-user-select: none;
78 | -ms-user-select: none;
79 | user-select: none;
80 | border: 1px solid transparent;
81 | padding: .5rem 1.5rem;
82 | border-radius: 30px;
83 | font-size: 1rem;
84 | line-height: 1.5;
85 | -webkit-transition: color 0.15s ease-in-out,background-color 0.15s ease-in-out,border-color 0.15s ease-in-out,-webkit-box-shadow 0.15s ease-in-out;
86 | transition: color 0.15s ease-in-out,background-color 0.15s ease-in-out,border-color 0.15s ease-in-out,-webkit-box-shadow 0.15s ease-in-out;
87 | -o-transition: color 0.15s ease-in-out,background-color 0.15s ease-in-out,border-color 0.15s ease-in-out,box-shadow 0.15s ease-in-out;
88 | transition: color 0.15s ease-in-out,background-color 0.15s ease-in-out,border-color 0.15s ease-in-out,box-shadow 0.15s ease-in-out;
89 | transition: color 0.15s ease-in-out,background-color 0.15s ease-in-out,border-color 0.15s ease-in-out,box-shadow 0.15s ease-in-out,-webkit-box-shadow 0.15s ease-in-out;
90 | color: #5396fd;
91 | background-color: transparent;
92 | background-image: none;
93 | border-color: #5396fd;
94 | }
95 | button:hover,
96 | button:focus {
97 | color: #fff;
98 | background-color: #5396fd;
99 | border-color: #5396fd;
100 | cursor: pointer;
101 | }
102 |
103 | .btn {
104 | padding: .5rem 1.5rem;
105 | border-radius: 30px;
106 | }
107 | .btn-lg {
108 | padding: .5rem 1.5rem;
109 | }
110 | .btn-outline-primary {
111 | color: #5396fd;
112 | background-color: transparent;
113 | background-image: none;
114 | border-color: #5396fd;
115 | }
116 | .btn-outline-primary:hover,
117 | .btn-outline-primary:focus {
118 | color: #fff;
119 | background-color: #5396fd;
120 | border-color: #5396fd;
121 | }
122 |
123 | .btn-outline-secondary {
124 | color: #7973b3;
125 | background-color: transparent;
126 | background-image: none;
127 | border-color: #7973b3;
128 | }
129 | .btn-outline-secondary:hover,
130 | .btn-outline-secondary:focus {
131 | color: #fff;
132 | background-color: #7973b3;
133 | border-color: #7973b3;
134 | }
135 |
136 | /* Forms */
137 |
138 | input[type="text"], select {
139 | display: block;
140 | width: 100%;
141 | padding: 0 0 1px;
142 | background: none;
143 | border: none;
144 | border-bottom: 2px solid #5396fd;
145 | outline: none;
146 | color: #fff;
147 | }
148 |
149 | label {
150 | margin-bottom: 5px;
151 | }
152 |
153 | .field {
154 | margin-bottom: 40px;
155 | }
156 |
157 | .form-control {
158 | display: block;
159 | width: 100%;
160 | padding: 0 0 1px;
161 | background: none;
162 | border: none;
163 | border-bottom: 2px solid #5396fd;
164 | outline: none;
165 | color: #fff;
166 | }
167 | textarea.form-control {
168 | padding: 5px 10px;
169 | background: rgba(0,0,0,0.2);
170 | border: 2px solid #5396fd;
171 | }
172 |
173 | .help {
174 | color: #bbb;
175 | font-size: 13px;
176 | margin-top: .3rem;
177 | padding: 0 5px;
178 | }
179 |
180 | .form-field {
181 | margin-bottom: 40px;
182 | }
183 |
184 | /* Semantic UI */
185 | .ui.selection.dropdown {
186 | background: none;
187 | color:#fff;
188 | border-radius: 0px;
189 | -webkit-appearance: none;
190 | -webkit-border-radius: 0px;
191 | padding: 3px 0px;
192 | min-height:auto;
193 | border:none;
194 | border-bottom: 2px solid #5396fd;
195 | }
196 | .ui.selection.dropdown .menu>.item, .ui.selection.active.dropdown, .ui.selection.active.dropdown .menu {
197 | border: none !important;
198 | background: #0f171c !important;
199 | }
200 | .ui.selection.dropdown:hover {
201 | border-bottom: 2px solid #5396fd;
202 | }
203 | .ui.selection.dropdown .menu>.item {
204 | background: none;
205 | color:#fff;
206 | }
207 | .ui.selection.dropdown .menu>.item:hover {
208 | background-color:#5396fd !important;
209 | }
210 | .ui.selection.visible.dropdown>.text:not(.default) {
211 | color:#fff;
212 | }
213 | .ui.selection.dropdown>.dropdown.icon {
214 | top: 0px;
215 | }
216 | .ui.dropdown>.text {
217 | padding: 0 0 0 10px;
218 | }
219 |
220 | @media (min-width: 768px) {
221 |
222 | .nav {
223 | clear: none;
224 | padding: 20px 20px;
225 | margin-bottom: 40px;
226 | text-align: left;
227 | }
228 | .nav li {
229 | display: inline-block;
230 | }
231 | .nav a {
232 | display: inline-block;
233 | padding: 10px 20px;
234 | color: #fff;
235 | }
236 |
237 | .field.is-horizontal {
238 | display: flex;
239 | }
240 | .field-label {
241 | flex-basis: 0;
242 | flex-grow: 1;
243 | flex-shrink: 0;
244 | margin-right: 2rem;
245 | text-align: right;
246 | }
247 | .field-body {
248 | display: flex;
249 | flex-basis: 0;
250 | flex-grow: 6;
251 | flex-shrink: 1;
252 | flex-flow: column;
253 | }
254 | }
255 |
--------------------------------------------------------------------------------
/tests/clevis.js:
--------------------------------------------------------------------------------
1 | const clevis = require("clevis")
2 | const colors = require('colors')
3 | const chai = require("chai")
4 | const assert = chai.assert
5 | const expect = chai.expect;
6 | const should = chai.should();
7 | const fs = require('fs')
8 | const Web3 = require('web3')
9 | const clevisConfig = JSON.parse(fs.readFileSync("clevis.json").toString().trim())
10 | web3 = new Web3(new Web3.providers.HttpProvider(clevisConfig.provider))
11 | function localContractAddress(contract){
12 | return fs.readFileSync(contract+"/"+contract+".address").toString().trim()
13 | }
14 | function localContractAbi(contract){
15 | return JSON.parse(fs.readFileSync(contract+"/"+contract+".abi").toString().trim())
16 | }
17 | function printTxResult(result){
18 | if(!result||!result.transactionHash){
19 | console.log("ERROR".red,"MISSING TX HASH".yellow)
20 | }else{
21 | console.log(tab,result.transactionHash.gray,(""+result.gasUsed).yellow)
22 | }
23 | }
24 | function bigHeader(str){
25 | return "########### "+str+" "+Array(128-str.length).join("#")
26 | }
27 | function rand(min, max) {
28 | return Math.floor( Math.random() * (max - min) + min );
29 | }
30 | function getPaddedHexFromNumber(num,digits){
31 | let hexIs = web3.utils.numberToHex(num).replace("0x","");
32 | while(hexIs.length
81 |
85 |
86 | )
87 | recipient = (
88 |
89 |
93 |
94 | )
95 | }else{
96 | let loader = ""
97 | if(this.props.deployingGrantContract){
98 | loader = (
99 |
104 | {loader}
109 |
110 | )
111 | recipient = (
112 |
113 |
122 | )
123 | }
124 |
125 | let descriptionContent;
126 |
127 | if (this.state.descriptionPreview === true) {
128 | descriptionContent =
118 |
119 |
121 | The address that will receive the funding tokens.
120 |
135 |
292 | );
293 | }
294 | }
295 |
296 | export default CreateGrants;
297 |
--------------------------------------------------------------------------------
/src/App.js:
--------------------------------------------------------------------------------
1 | import React, { Component } from 'react';
2 | import './App.css';
3 | import { Metamask, Gas, ContractLoader, Transactions, Button, Scaler } from "dapparatus"
4 | import Web3 from 'web3';
5 | import MainUI from './components/mainui.js'
6 | import Subscriber from './components/subscriber.js'
7 | import Publisher from './components/publisher.js'
8 | import PublisherDeploy from './components/publisherDeploy.js'
9 | import SubscriberApprove from './components/subscriberApprove.js'
10 | import Coins from './coins.js'
11 | import Logo from './logo-icon.png';
12 | import axios from 'axios'
13 |
14 | var RLP = require('rlp');
15 |
16 | let backendUrl = "http://localhost:10003/"
17 | if(window.location.href.indexOf("tokensubscription.com")>=0)
18 | {
19 | backendUrl = "https://relay.tokensubscription.com/"
20 | }
21 |
22 | class App extends Component {
23 | constructor(props) {
24 | super(props);
25 | let contract
26 | let subscription
27 | let path = window.location.pathname.replace("/","")
28 | if(path.length==42){
29 | contract = path
30 | }else if(path.length==66){
31 | subscription = path
32 | }else{
33 | console.log("PATH LENGTH UNKNWON",path,path.length)
34 | }
35 | let startMode = ""
36 | if(contract||subscription){
37 | startMode = "subscriber"
38 | }
39 |
40 | this.state = {
41 | web3: false,
42 | account: false,
43 | gwei: 4,
44 | doingTransaction: false,
45 | contract: contract,
46 | subscription: subscription,
47 | mode: startMode,
48 | coins:false,
49 | contractLink:""
50 | }
51 | }
52 |
53 | async deploySubscription(toAddress,tokenName,tokenAmount,timeType,timeAmount,gasPrice,email) {
54 | let {web3,tx,contracts} = this.state
55 |
56 |
57 | //requiredToAddress,requiredTokenAddress,requiredTokenAmount,requiredPeriodSeconds,requiredGasPrice
58 | let requiredToAddress = "0x0000000000000000000000000000000000000000"
59 | if(toAddress){
60 | requiredToAddress = toAddress
61 | }
62 |
63 | let foundToken
64 | let requiredTokenAddress = "0x0000000000000000000000000000000000000000"
65 | if(tokenName){
66 | //translate tokenName to tokenAddress
67 | for(let i = 0; i < this.state.coins.length; i++){
68 | if(tokenName == this.state.coins[i].address){
69 | requiredTokenAddress = this.state.coins[i].address
70 | foundToken = this.state.coins[i]
71 | }
72 | }
73 | }
74 |
75 | let requiredPeriodSeconds=0
76 | if(timeAmount){
77 | //translate timeAmount&timeType to requiredPeriodSeconds
78 | let periodSeconds = timeAmount;
79 | if(timeType=="minutes"){
80 | periodSeconds*=60
81 | }else if(timeType=="hours"){
82 | periodSeconds*=3600
83 | }else if(timeType=="days"){
84 | periodSeconds*=86400
85 | }else if(timeType=="months"){
86 | periodSeconds*=2592000
87 | }
88 | if(periodSeconds){
89 | requiredPeriodSeconds=periodSeconds
90 | }
91 | }
92 |
93 | let requiredTokenAmount=0
94 | let requiredGasPrice=0
95 | if(tokenAmount && foundToken){
96 | //don't forget decimals.. you do a number * (10**##DECIMALS##)
97 | requiredTokenAmount = tokenAmount * (10**foundToken.decimals)
98 | if(gasPrice && foundToken){
99 | //don't forget decimals.. you do a number * (10**##DECIMALS##)
100 | requiredGasPrice = gasPrice * (10**foundToken.decimals)
101 | requiredTokenAmount -= requiredGasPrice
102 | }
103 | }
104 |
105 |
106 | console.log("we can guess what the contract address is going to be, this let's us get the UI going without it being deployed yet...")
107 | let txCount = await this.state.web3.eth.getTransactionCount(this.state.account,'pending')
108 | let deployingAddress = "0x"+this.state.web3.utils.keccak256(RLP.encode([this.state.account,txCount])).substr(26)
109 | this.setState({deployingAddress:deployingAddress})
110 |
111 | console.log("Deploying Subscription Contract...")
112 | let code = require("./contracts/Subscription.bytecode.js")
113 |
114 | let args = [
115 | requiredToAddress,
116 | requiredTokenAddress,
117 | web3.utils.toTwosComplement(requiredTokenAmount),
118 | web3.utils.toTwosComplement(requiredPeriodSeconds),
119 | web3.utils.toTwosComplement(requiredGasPrice)
120 | ]
121 |
122 | console.log("ARGS",args)
123 |
124 | tx(contracts.Subscription._contract.deploy({data:code,arguments:args}),1500000,(receipt)=>{
125 | console.log("~~~~~~ DEPLOY FROM DAPPARATUS:",receipt)
126 | if(receipt.contractAddress){
127 | console.log("CONTRACT DEPLOYED:",receipt.contractAddress)
128 | this.setState({deployedAddress:receipt.contractAddress})
129 | }
130 | })
131 |
132 | axios.post(backendUrl+'deploysub',{arguments:args,email:email,deployingAddress:deployingAddress}, {
133 | headers: {
134 | 'Content-Type': 'application/json',
135 | }
136 | }).then((response)=>{
137 | console.log("SAVED INFO",response.data)
138 | })
139 | .catch((error)=>{
140 | console.log(error);
141 | });
142 |
143 |
144 | }
145 | setMode(mode){
146 | this.setState({mode:mode})
147 | }
148 | handleInput(e){
149 | let update = {}
150 | update[e.target.name] = e.target.value
151 | this.setState(update)
152 | }
153 | render() {
154 |
155 |
156 | const { error, isLoaded, items } = this.state;
157 | let {web3,account,contracts,tx,gwei,block,avgBlockTime,etherscan,mode,deployingAddress,deployedAddress} = this.state
158 | let connectedDisplay = []
159 | let contractsDisplay = []
160 | let noWeb3Display = ""
161 | if(web3){
162 | connectedDisplay.push(
163 | Create A Grant
136 | 137 |
138 |
290 |
291 |
139 |
146 |
147 |
140 |
141 |
142 |
143 |
144 |
145 |
148 |
156 |
157 |
149 |
150 |
151 |
152 |
153 |
155 | Your short elevator pitch.
154 |
158 |
165 |
166 |
159 |
160 |
161 |
162 | {recipient}
163 |
164 |
167 |
177 |
178 |
168 |
169 |
170 |
171 |
176 |
172 | {deployedContract}
173 |
174 | Deploy the grant contract.
175 |
179 |
202 |
203 |
180 |
181 |
183 | (Markdown)
182 |
184 |
201 |
185 |
188 | Edit Mode
189 |
190 | {this.togglePreview('preview')}}>
193 | Preview Mode
194 |
195 |
196 |
197 | {descriptionContent}
198 |
199 | A longer, more detailed description can be written in Markdown.
200 |
204 |
212 |
213 |
205 |
206 |
207 |
208 |
209 |
211 | Amount in (USD) you would like to receive each month.
210 |
214 |
222 |
223 |
215 |
216 |
217 |
218 |
219 |
221 | Expected duration you would like to receive funding.
220 |
224 |
232 |
233 |
225 |
226 |
227 |
228 |
229 |
231 | Your full name.
230 |
234 |
242 |
243 |
235 |
236 |
237 |
238 |
239 |
241 | A valid email address.
240 |
244 |
288 |
289 |
245 |
246 |
247 |
248 |
287 |
249 |
285 |
286 |
243 | subscriber deploy page {deployingAddress} => {deployedAddress}
244 |
245 | )
246 | }else{
247 | body = (
248 |
278 |
282 | )
283 | }else{
284 | connectedDisplay.push(
285 |
279 | {body}
280 |
281 | 
307 |
308 | )
309 | }
310 |
311 | return (
312 |
313 |
314 | {forkBanner}
315 |
316 | {
329 | console.log("metamask state update:",state)
330 | if(state.web3Provider) {
331 | state.web3 = new Web3(state.web3Provider)
332 | this.setState(state)
333 | }
334 | }}
335 | />
336 |
342 | );
343 | }
344 | }
345 |
346 |
347 |
348 | export default App;
349 |
--------------------------------------------------------------------------------
/TokenExampleSubscriptionToken/TokenExampleSubscriptionToken.compiled:
--------------------------------------------------------------------------------
1 | pragma solidity ^0.4.24;
2 |
3 | /*
4 | TEST token for tokensubscription.com
5 | */
6 |
7 |
8 |
9 |
10 |
11 | /**
12 | * @title ERC20 interface
13 | * @dev see https://github.com/ethereum/EIPs/issues/20
14 | */
15 | interface IERC20 {
16 | function totalSupply() external view returns (uint256);
17 |
18 | function balanceOf(address who) external view returns (uint256);
19 |
20 | function allowance(address owner, address spender)
21 | external view returns (uint256);
22 |
23 | function transfer(address to, uint256 value) external returns (bool);
24 |
25 | function approve(address spender, uint256 value)
26 | external returns (bool);
27 |
28 | function transferFrom(address from, address to, uint256 value)
29 | external returns (bool);
30 |
31 | event Transfer(
32 | address indexed from,
33 | address indexed to,
34 | uint256 value
35 | );
36 |
37 | event Approval(
38 | address indexed owner,
39 | address indexed spender,
40 | uint256 value
41 | );
42 | }
43 |
44 |
45 |
46 | /**
47 | * @title SafeMath
48 | * @dev Math operations with safety checks that revert on error
49 | */
50 | library SafeMath {
51 |
52 | /**
53 | * @dev Multiplies two numbers, reverts on overflow.
54 | */
55 | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
56 | // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
57 | // benefit is lost if 'b' is also tested.
58 | // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
59 | if (a == 0) {
60 | return 0;
61 | }
62 |
63 | uint256 c = a * b;
64 | require(c / a == b);
65 |
66 | return c;
67 | }
68 |
69 | /**
70 | * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
71 | */
72 | function div(uint256 a, uint256 b) internal pure returns (uint256) {
73 | require(b > 0); // Solidity only automatically asserts when dividing by 0
74 | uint256 c = a / b;
75 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold
76 |
77 | return c;
78 | }
79 |
80 | /**
81 | * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
82 | */
83 | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
84 | require(b <= a);
85 | uint256 c = a - b;
86 |
87 | return c;
88 | }
89 |
90 | /**
91 | * @dev Adds two numbers, reverts on overflow.
92 | */
93 | function add(uint256 a, uint256 b) internal pure returns (uint256) {
94 | uint256 c = a + b;
95 | require(c >= a);
96 |
97 | return c;
98 | }
99 |
100 | /**
101 | * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
102 | * reverts when dividing by zero.
103 | */
104 | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
105 | require(b != 0);
106 | return a % b;
107 | }
108 | }
109 |
110 |
111 |
112 | /**
113 | * @title Standard ERC20 token
114 | *
115 | * @dev Implementation of the basic standard token.
116 | * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
117 | * Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
118 | */
119 | contract ERC20 is IERC20 {
120 | using SafeMath for uint256;
121 |
122 | mapping (address => uint256) private _balances;
123 |
124 | mapping (address => mapping (address => uint256)) private _allowed;
125 |
126 | uint256 private _totalSupply;
127 |
128 | /**
129 | * @dev Total number of tokens in existence
130 | */
131 | function totalSupply() public view returns (uint256) {
132 | return _totalSupply;
133 | }
134 |
135 | /**
136 | * @dev Gets the balance of the specified address.
137 | * @param owner The address to query the the balance of.
138 | * @return An uint256 representing the amount owned by the passed address.
139 | */
140 | function balanceOf(address owner) public view returns (uint256) {
141 | return _balances[owner];
142 | }
143 |
144 | /**
145 | * @dev Function to check the amount of tokens that an owner allowed to a spender.
146 | * @param owner address The address which owns the funds.
147 | * @param spender address The address which will spend the funds.
148 | * @return A uint256 specifying the amount of tokens still available for the spender.
149 | */
150 | function allowance(
151 | address owner,
152 | address spender
153 | )
154 | public
155 | view
156 | returns (uint256)
157 | {
158 | return _allowed[owner][spender];
159 | }
160 |
161 | /**
162 | * @dev Transfer token for a specified address
163 | * @param to The address to transfer to.
164 | * @param value The amount to be transferred.
165 | */
166 | function transfer(address to, uint256 value) public returns (bool) {
167 | require(value <= _balances[msg.sender]);
168 | require(to != address(0));
169 |
170 | _balances[msg.sender] = _balances[msg.sender].sub(value);
171 | _balances[to] = _balances[to].add(value);
172 | emit Transfer(msg.sender, to, value);
173 | return true;
174 | }
175 |
176 | /**
177 | * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
178 | * Beware that changing an allowance with this method brings the risk that someone may use both the old
179 | * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
180 | * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
181 | * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
182 | * @param spender The address which will spend the funds.
183 | * @param value The amount of tokens to be spent.
184 | */
185 | function approve(address spender, uint256 value) public returns (bool) {
186 | require(spender != address(0));
187 |
188 | _allowed[msg.sender][spender] = value;
189 | emit Approval(msg.sender, spender, value);
190 | return true;
191 | }
192 |
193 | /**
194 | * @dev Transfer tokens from one address to another
195 | * @param from address The address which you want to send tokens from
196 | * @param to address The address which you want to transfer to
197 | * @param value uint256 the amount of tokens to be transferred
198 | */
199 | function transferFrom(
200 | address from,
201 | address to,
202 | uint256 value
203 | )
204 | public
205 | returns (bool)
206 | {
207 | require(value <= _balances[from]);
208 | require(value <= _allowed[from][msg.sender]);
209 | require(to != address(0));
210 |
211 | _balances[from] = _balances[from].sub(value);
212 | _balances[to] = _balances[to].add(value);
213 | _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
214 | emit Transfer(from, to, value);
215 | return true;
216 | }
217 |
218 | /**
219 | * @dev Increase the amount of tokens that an owner allowed to a spender.
220 | * approve should be called when allowed_[_spender] == 0. To increment
221 | * allowed value is better to use this function to avoid 2 calls (and wait until
222 | * the first transaction is mined)
223 | * From MonolithDAO Token.sol
224 | * @param spender The address which will spend the funds.
225 | * @param addedValue The amount of tokens to increase the allowance by.
226 | */
227 | function increaseAllowance(
228 | address spender,
229 | uint256 addedValue
230 | )
231 | public
232 | returns (bool)
233 | {
234 | require(spender != address(0));
235 |
236 | _allowed[msg.sender][spender] = (
237 | _allowed[msg.sender][spender].add(addedValue));
238 | emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
239 | return true;
240 | }
241 |
242 | /**
243 | * @dev Decrease the amount of tokens that an owner allowed to a spender.
244 | * approve should be called when allowed_[_spender] == 0. To decrement
245 | * allowed value is better to use this function to avoid 2 calls (and wait until
246 | * the first transaction is mined)
247 | * From MonolithDAO Token.sol
248 | * @param spender The address which will spend the funds.
249 | * @param subtractedValue The amount of tokens to decrease the allowance by.
250 | */
251 | function decreaseAllowance(
252 | address spender,
253 | uint256 subtractedValue
254 | )
255 | public
256 | returns (bool)
257 | {
258 | require(spender != address(0));
259 |
260 | _allowed[msg.sender][spender] = (
261 | _allowed[msg.sender][spender].sub(subtractedValue));
262 | emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
263 | return true;
264 | }
265 |
266 | /**
267 | * @dev Internal function that mints an amount of the token and assigns it to
268 | * an account. This encapsulates the modification of balances such that the
269 | * proper events are emitted.
270 | * @param account The account that will receive the created tokens.
271 | * @param amount The amount that will be created.
272 | */
273 | function _mint(address account, uint256 amount) internal {
274 | require(account != 0);
275 | _totalSupply = _totalSupply.add(amount);
276 | _balances[account] = _balances[account].add(amount);
277 | emit Transfer(address(0), account, amount);
278 | }
279 |
280 | /**
281 | * @dev Internal function that burns an amount of the token of a given
282 | * account.
283 | * @param account The account whose tokens will be burnt.
284 | * @param amount The amount that will be burnt.
285 | */
286 | function _burn(address account, uint256 amount) internal {
287 | require(account != 0);
288 | require(amount <= _balances[account]);
289 |
290 | _totalSupply = _totalSupply.sub(amount);
291 | _balances[account] = _balances[account].sub(amount);
292 | emit Transfer(account, address(0), amount);
293 | }
294 |
295 | /**
296 | * @dev Internal function that burns an amount of the token of a given
297 | * account, deducting from the sender's allowance for said account. Uses the
298 | * internal burn function.
299 | * @param account The account whose tokens will be burnt.
300 | * @param amount The amount that will be burnt.
301 | */
302 | function _burnFrom(address account, uint256 amount) internal {
303 | require(amount <= _allowed[account][msg.sender]);
304 |
305 | // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
306 | // this function needs to emit an event with the updated approval.
307 | _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
308 | amount);
309 | _burn(account, amount);
310 | }
311 | }
312 |
313 |
314 |
315 |
316 | /**
317 | * @title Roles
318 | * @dev Library for managing addresses assigned to a Role.
319 | */
320 | library Roles {
321 | struct Role {
322 | mapping (address => bool) bearer;
323 | }
324 |
325 | /**
326 | * @dev give an account access to this role
327 | */
328 | function add(Role storage role, address account) internal {
329 | require(account != address(0));
330 | role.bearer[account] = true;
331 | }
332 |
333 | /**
334 | * @dev remove an account's access to this role
335 | */
336 | function remove(Role storage role, address account) internal {
337 | require(account != address(0));
338 | role.bearer[account] = false;
339 | }
340 |
341 | /**
342 | * @dev check if an account has this role
343 | * @return bool
344 | */
345 | function has(Role storage role, address account)
346 | internal
347 | view
348 | returns (bool)
349 | {
350 | require(account != address(0));
351 | return role.bearer[account];
352 | }
353 | }
354 |
355 |
356 |
357 | contract MinterRole {
358 | using Roles for Roles.Role;
359 |
360 | event MinterAdded(address indexed account);
361 | event MinterRemoved(address indexed account);
362 |
363 | Roles.Role private minters;
364 |
365 | constructor() public {
366 | minters.add(msg.sender);
367 | }
368 |
369 | modifier onlyMinter() {
370 | require(isMinter(msg.sender));
371 | _;
372 | }
373 |
374 | function isMinter(address account) public view returns (bool) {
375 | return minters.has(account);
376 | }
377 |
378 | function addMinter(address account) public onlyMinter {
379 | minters.add(account);
380 | emit MinterAdded(account);
381 | }
382 |
383 | function renounceMinter() public {
384 | minters.remove(msg.sender);
385 | }
386 |
387 | function _removeMinter(address account) internal {
388 | minters.remove(account);
389 | emit MinterRemoved(account);
390 | }
391 | }
392 |
393 |
394 |
395 | /**
396 | * @title ERC20Mintable
397 | * @dev ERC20 minting logic
398 | */
399 | contract ERC20Mintable is ERC20, MinterRole {
400 | event MintingFinished();
401 |
402 | bool private _mintingFinished = false;
403 |
404 | modifier onlyBeforeMintingFinished() {
405 | require(!_mintingFinished);
406 | _;
407 | }
408 |
409 | /**
410 | * @return true if the minting is finished.
411 | */
412 | function mintingFinished() public view returns(bool) {
413 | return _mintingFinished;
414 | }
415 |
416 | /**
417 | * @dev Function to mint tokens
418 | * @param to The address that will receive the minted tokens.
419 | * @param amount The amount of tokens to mint.
420 | * @return A boolean that indicates if the operation was successful.
421 | */
422 | function mint(
423 | address to,
424 | uint256 amount
425 | )
426 | public
427 | onlyMinter
428 | onlyBeforeMintingFinished
429 | returns (bool)
430 | {
431 | _mint(to, amount);
432 | return true;
433 | }
434 |
435 | /**
436 | * @dev Function to stop minting new tokens.
437 | * @return True if the operation was successful.
438 | */
439 | function finishMinting()
440 | public
441 | onlyMinter
442 | onlyBeforeMintingFinished
443 | returns (bool)
444 | {
445 | _mintingFinished = true;
446 | emit MintingFinished();
447 | return true;
448 | }
449 | }
450 |
451 |
452 | contract TokenExampleSubscriptionToken is ERC20Mintable {
453 |
454 | string public name = "TokenExampleSubscriptionToken";
455 | string public symbol = "TEST";
456 | uint8 public decimals = 18;
457 |
458 | constructor() public { }
459 |
460 | }
461 |
462 |
463 |
464 |
465 |
466 |
467 |
--------------------------------------------------------------------------------
/src/components/subscriber.js:
--------------------------------------------------------------------------------
1 | import React, { Component } from 'react';
2 | import { Address, Blockie, Scaler } from "dapparatus"
3 | import axios from 'axios'
4 | import Loader from '../loader.gif';
5 | import Particles from './particles.js';
6 | import { Dropdown } from 'semantic-ui-react'
7 |
8 | let monthOptions = [
9 | {key: 'months', value: 'months', text: 'Month(s)'},
10 | {key: 'days', value: 'days', text: 'Day(s)'},
11 | {key: 'hours', value: 'hours', text: 'Hour(s)'},
12 | {key: 'minutes', value: 'minutes', text: 'Minutes(s)'},
13 | ]
14 |
15 | class Subscriber extends Component {
16 | constructor(props) {
17 | super(props);
18 | this.state = {
19 | toAddress: "",
20 |
21 | prefilledParams:false,
22 | tokenAmount: 10,
23 | timeAmount: 1,
24 | timeType:"months",
25 | tokenAddress:"0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359",
26 | gasPrice:0.25,
27 | tokenName:"DAI",
28 |
29 | };
30 | }
31 | handleInput(e,data){
32 | let update = {}
33 | if(data){
34 | update[data.name] = data.value
35 | if(data.name=="tokenAddress"&&data.value=="0x0000000000000000000000000000000000000000"){
36 | update.tokenAmount=""
37 | update.gasPrice=""
38 | update.timeAmount=""
39 | }else{
40 | if(this.state.tokenAmount==""){
41 | update.tokenAmount=1
42 | }
43 | if(this.state.gasPrice==""){
44 | update.gasPrice=0.25
45 | }
46 | if(this.state.timeAmount==""){
47 | update.timeAmount=1
48 | }
49 | }
50 | }else{
51 | update[e.target.name] = e.target.value
52 | }
53 | // console.log("==== UPDATE",update)
54 | this.setState(update,()=>{
55 | this.updateUrl()
56 | })
57 | }
58 | updateUrl(){
59 | let url = window.location.origin+window.location.pathname+
60 | "?timeAmount="+this.state.timeAmount+
61 | "&timeType="+this.state.timeType
62 | if(this.state.toAddress) url+="&toAddress="+this.state.toAddress
63 | if(this.state.tokenAddress) url+="&tokenAddress="+this.state.tokenAddress
64 | if(this.state.tokenAmount) url+="&tokenAmount="+this.state.tokenAmount
65 | if(this.state.gasPrice) url+="&gasPrice="+this.state.gasPrice
66 |
67 | this.setState({url:url})
68 | }
69 | async sendSubscription(){
70 | let {backendUrl,web3,account,contract} = this.props
71 | let {toAddress,timeType,tokenAmount,tokenAddress,gasPrice} = this.state
72 |
73 | let subscriptionContract = this.props.customContractLoader("Subscription",this.props.contract)
74 |
75 | let value = 0
76 | let txData = "0x02" //something like this to say, hardcoded VERSION 2, we're sending approved tokens
77 | let gasLimit = 120000
78 |
79 | let periodSeconds = this.state.timeAmount;
80 | if(timeType=="minutes"){
81 | periodSeconds*=60
82 | }else if(timeType=="hours"){
83 | periodSeconds*=3600
84 | }else if(timeType=="days"){
85 | periodSeconds*=86400
86 | }else if(timeType=="months"){
87 | periodSeconds*=2592000
88 | }
89 |
90 | if(!gasPrice) gasPrice = 0
91 |
92 | let nonce = parseInt(await subscriptionContract.extraNonce(account).call())+1
93 |
94 | //TODO know decimals and convert here
95 | let realTokenAmount = tokenAmount*10**18
96 | let realGasPrice = gasPrice*10**18
97 | /*
98 | address from, //the subscriber
99 | address to, //the publisher
100 | address tokenAddress, //the token address paid to the publisher
101 | uint256 tokenAmount, //the token amount paid to the publisher
102 | uint256 periodSeconds, //the period in seconds between payments
103 | uint256 gasPrice, //the amount of tokens or eth to pay relayer (0 for free)
104 | */
105 |
106 | const parts = [
107 | account,
108 | toAddress,
109 | tokenAddress,
110 | web3.utils.toTwosComplement(realTokenAmount),
111 | web3.utils.toTwosComplement(periodSeconds),
112 | web3.utils.toTwosComplement(realGasPrice),
113 | web3.utils.toTwosComplement(nonce)
114 | ]
115 | /*web3.utils.padLeft("0x"+nonce,64),*/
116 | console.log("PARTS",parts)
117 |
118 | const subscriptionHash = await subscriptionContract.getSubscriptionHash(...parts).call()
119 | console.log("subscriptionHash",subscriptionHash)
120 |
121 | let signature = await web3.eth.personal.sign(""+subscriptionHash,account)
122 | console.log("signature",signature)
123 | let postData = {
124 | subscriptionContract:subscriptionContract._address,
125 | parts:parts,
126 | subscriptionHash: subscriptionHash,
127 | signature:signature,
128 | }
129 |
130 | console.log("postData",postData)
131 | axios.post(backendUrl+'saveSubscription', postData, {
132 | headers: {
133 | 'Content-Type': 'application/json',
134 | }
135 | }).then((response)=>{
136 | console.log("TX RESULT",response.data.subscriptionHash)
137 | window.location = "/"+response.data.subscriptionHash
138 | })
139 | .catch((error)=>{
140 | console.log(error);
141 | });
142 | }
143 |
144 | async componentDidMount() {
145 | let {contracts} = this.props
146 | console.log("contracts",contracts)
147 | this.setState({
148 | isLoaded: true,
149 | items: [ {
150 | address: this.props.contracts.WasteCoin._address,
151 | decimals: 18,
152 | name: "WasteCoin",
153 | symbol: "WC"
154 | } ]
155 | })
156 | if(this.props.contract){
157 | console.log("poll contract for values...")
158 | let subscriptionsContract = this.props.customContractLoader("Subscription",this.props.contract)
159 | console.log("subscriptionsContract",subscriptionsContract)
160 | let requiredToAddress = await subscriptionsContract.requiredToAddress().call()
161 | let requiredTokenAddress = await subscriptionsContract.requiredTokenAddress().call()
162 |
163 | let requiredTokenName
164 | let tokenDecimals = 0
165 |
166 | if(requiredTokenAddress && requiredTokenAddress!="0x0000000000000000000000000000000000000000"){
167 | console.log("using",requiredTokenAddress,"search through",this.props.coins)
168 | for(let c in this.props.coins){
169 | console.log("CHECKING",this.props.coins[c])
170 | if(this.props.coins[c] && this.props.coins[c].address && this.props.coins[c].address.toLowerCase()==requiredTokenAddress.toLowerCase()){
171 | console.log("FOUND!!!!!!!!")
172 | requiredTokenName = this.props.coins[c].name
173 | tokenDecimals = this.props.coins[c].decimals
174 | }
175 | }
176 | let requiredTokenAmount = await subscriptionsContract.requiredTokenAmount().call()
177 | console.log("requiredTokenAmount",requiredTokenAmount)
178 | let requiredPeriodSeconds = await subscriptionsContract.requiredPeriodSeconds().call()
179 | let requiredTimeAmount = 0
180 | let requiredTimeType = ""
181 | if(requiredPeriodSeconds){
182 | if(requiredPeriodSeconds>=2592000){
183 | requiredTimeAmount = requiredPeriodSeconds/2592000
184 | requiredTimeType = "months"
185 | }else if(requiredPeriodSeconds>=86400){
186 | requiredTimeAmount = requiredPeriodSeconds/86400
187 | requiredTimeType = "days"
188 | }else if(requiredPeriodSeconds>=3600){
189 | requiredTimeAmount = requiredPeriodSeconds/3600
190 | requiredTimeType = "hours"
191 | }else{
192 | requiredTimeAmount = requiredPeriodSeconds/60
193 | requiredTimeType = "minutes"
194 | }
195 | }
196 | let requiredGasPrice = await subscriptionsContract.requiredGasPrice().call()
197 | if(tokenDecimals){
198 | requiredGasPrice=requiredGasPrice/(10**tokenDecimals)
199 | requiredTokenAmount=requiredTokenAmount/(10**tokenDecimals)
200 | }
201 | console.log("requiredTokenAmount",requiredTokenAmount)
202 | console.log(requiredGasPrice);
203 | this.setState({
204 | requiredTokenAddress:requiredTokenAddress,
205 | prefilledParams:true,
206 | toAddress:requiredToAddress,
207 | tokenAddress:requiredTokenAddress,
208 | tokenAmount:requiredTokenAmount,
209 | tokenName:requiredTokenName,
210 | timeAmount:requiredTimeAmount,
211 | timeType:requiredTimeType,
212 | gasPrice:requiredGasPrice,
213 | })
214 | }else{
215 |
216 | console.log("=====---- This is an open ended subscription without parameters...")
217 | //this is an open ended model, set some defaults....
218 | this.setState({
219 | requiredTokenAddress:requiredTokenAddress,
220 | toAddress:requiredToAddress,
221 | prefilledParams: true,
222 | tokenAmount: 10,
223 | timeAmount: 1,
224 | timeType:"months",
225 | tokenAddress:"0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359",
226 | gasPrice:0.25
227 | },()=>{
228 | console.log(this.state)
229 | })
230 |
231 |
232 | }
233 |
234 |
235 | }
236 | }
237 | render() {
238 | let {contract,coins} = this.props
239 | let {items,toAddress,tokenName,tokenAmount,tokenAddress,timeType,timeAmount,gasPrice,prefilledParams,email,requiredTokenAddress} = this.state
240 | console.log("timeType:",timeType)
241 | let coinOptions = []
242 | for(let i in items){
243 | //console.log(items[i].name)
244 | coinOptions.push(
245 |
246 | )
247 | }
248 | if(contract){
249 | if(!prefilledParams&&requiredTokenAddress!="0x0000000000000000000000000000000000000000"){
250 | return (
251 |
337 | {connectedDisplay}
338 | {contractsDisplay}
339 | {noWeb3Display}
340 |
341 |
278 |
279 |
285 |
286 |
287 |
300 |
301 |
302 |
303 |
313 |
314 |
315 |
318 |
319 |
320 |
321 |
324 |
325 |
330 |
342 |
343 |
348 |
349 | {tokenName}
350 |
351 |
352 | {parseFloat(tokenAmount) + parseFloat(gasPrice)}
353 |
354 |
355 | Recurring Every: {timeAmount} {timeType}
356 |
357 |
362 |
370 | 
371 |
373 | );
374 | }
375 |
376 | }
377 | }
378 |
379 | export default Subscriber;
380 |
--------------------------------------------------------------------------------
/Subscription/Subscription.sol:
--------------------------------------------------------------------------------
1 | pragma solidity ^0.4.24;
2 |
3 | /*
4 | Super Simple Token Subscriptions - https://tokensubscription.com
5 |
6 | //// Breakin’ Through @ University of Wyoming ////
7 |
8 | Austin Thomas Griffith - https://austingriffith.com
9 |
10 | Building on previous works:
11 | https://github.com/austintgriffith/token-subscription
12 | https://gist.github.com/androolloyd/0a62ef48887be00a5eff5c17f2be849a
13 | https://media.consensys.net/subscription-services-on-the-blockchain-erc-948-6ef64b083a36
14 | https://medium.com/gitcoin/technical-deep-dive-architecture-choices-for-subscriptions-on-the-blockchain-erc948-5fae89cabc7a
15 | https://github.com/ethereum/EIPs/pull/1337
16 | https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1077.md
17 | https://github.com/gnosis/safe-contracts
18 |
19 | Earlier Meta Transaction Demo:
20 | https://github.com/austintgriffith/bouncer-proxy
21 |
22 | Huge thanks, as always, to OpenZeppelin for the rad contracts:
23 | */
24 |
25 | import "openzeppelin-solidity/contracts/cryptography/ECDSA.sol";
26 | import "openzeppelin-solidity/contracts/math/SafeMath.sol";
27 | import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
28 |
29 |
30 | contract Subscription {
31 | using ECDSA for bytes32;
32 | using SafeMath for uint256;
33 |
34 | //who deploys the contract
35 | address public author;
36 | uint8 public contractVersion;
37 |
38 | // the publisher may optionally deploy requirements for the subscription
39 | // so only meta transactions that match the requirements can be relayed
40 | address public requiredToAddress;
41 | address public requiredTokenAddress;
42 | uint256 public requiredTokenAmount;
43 | uint256 public requiredPeriodSeconds;
44 | uint256 public requiredGasPrice;
45 |
46 |
47 | // similar to a nonce that avoids replay attacks this allows a single execution
48 | // every x seconds for a given subscription
49 | // subscriptionHash => next valid block number
50 | mapping(bytes32 => uint256) public nextValidTimestamp;
51 |
52 | //we'll use a nonce for each from but because transactions can go through
53 | //multiple times, we allow anything but users can use this as a signal for
54 | //uniqueness
55 | mapping(address => uint256) public extraNonce;
56 |
57 | event ExecuteSubscription(
58 | address indexed from, //the subscriber
59 | address indexed to, //the publisher
60 | address tokenAddress, //the token address paid to the publisher
61 | uint256 tokenAmount, //the token amount paid to the publisher
62 | uint256 periodSeconds, //the period in seconds between payments
63 | uint256 gasPrice, //the amount of tokens to pay relayer (0 for free)
64 | uint256 nonce // to allow multiple subscriptions with the same parameters
65 | );
66 |
67 | event CancelSubscription(
68 | address indexed from, //the subscriber
69 | address indexed to, //the publisher
70 | address tokenAddress, //the token address paid to the publisher
71 | uint256 tokenAmount, //the token amount paid to the publisher
72 | uint256 periodSeconds, //the period in seconds between payments
73 | uint256 gasPrice, //the amount of tokens to pay relayer (0 for free)
74 | uint256 nonce // to allow multiple subscriptions with the same parameters
75 | );
76 |
77 | constructor(
78 | address _toAddress,
79 | address _tokenAddress,
80 | uint256 _tokenAmount,
81 | uint256 _periodSeconds,
82 | uint256 _gasPrice,
83 | uint8 _version
84 | ) public {
85 | requiredToAddress=_toAddress;
86 | requiredTokenAddress=_tokenAddress;
87 | requiredTokenAmount=_tokenAmount;
88 | requiredPeriodSeconds=_periodSeconds;
89 | requiredGasPrice=_gasPrice;
90 | author=msg.sender;
91 | contractVersion=_version;
92 | }
93 |
94 | // this is used by external smart contracts to verify on-chain that a
95 | // particular subscription is "paid" and "active"
96 | // there must be a small grace period added to allow the publisher
97 | // or desktop miner to execute
98 | function isSubscriptionActive(
99 | bytes32 subscriptionHash,
100 | uint256 gracePeriodSeconds
101 | )
102 | external
103 | view
104 | returns (bool)
105 | {
106 | if(nextValidTimestamp[subscriptionHash]==uint256(-1)){
107 | return false;
108 | }
109 | return (block.timestamp <=
110 | nextValidTimestamp[subscriptionHash].add(gracePeriodSeconds)
111 | );
112 | }
113 |
114 | // given the subscription details, generate a hash and try to kind of follow
115 | // the eip-191 standard and eip-1077 standard from my dude @avsa
116 | function getSubscriptionHash(
117 | address from, //the subscriber
118 | address to, //the publisher
119 | address tokenAddress, //the token address paid to the publisher
120 | uint256 tokenAmount, //the token amount paid to the publisher
121 | uint256 periodSeconds, //the period in seconds between payments
122 | uint256 gasPrice, //the amount of tokens or eth to pay relayer (0 for free)
123 | uint256 nonce // to allow multiple subscriptions with the same parameters
124 | )
125 | public
126 | view
127 | returns (bytes32)
128 | {
129 | // if there are requirements from the deployer, let's make sure
130 | // those are met exactly
131 | require( requiredToAddress == address(0) || to == requiredToAddress, "requiredToAddress Failure" );
132 | require( requiredTokenAddress == address(0) || tokenAddress == requiredTokenAddress, "requiredTokenAddress Failure" );
133 | require( requiredTokenAmount == 0 || tokenAmount == requiredTokenAmount, "requiredTokenAmount Failure" );
134 | require( requiredPeriodSeconds == 0 || periodSeconds == requiredPeriodSeconds, "requiredPeriodSeconds Failure" );
135 | require( requiredGasPrice == 0 || gasPrice == requiredGasPrice, "requiredGasPrice Failure" );
136 |
137 | return keccak256(
138 | abi.encodePacked(
139 | byte(0x19),
140 | byte(0),
141 | address(this),
142 | from,
143 | to,
144 | tokenAddress,
145 | tokenAmount,
146 | periodSeconds,
147 | gasPrice,
148 | nonce
149 | ));
150 | }
151 |
152 | //ecrecover the signer from hash and the signature
153 | function getSubscriptionSigner(
154 | bytes32 subscriptionHash, //hash of subscription
155 | bytes signature //proof the subscriber signed the meta trasaction
156 | )
157 | public
158 | pure
159 | returns (address)
160 | {
161 | return subscriptionHash.toEthSignedMessageHash().recover(signature);
162 | }
163 |
164 | //check if a subscription is signed correctly and the timestamp is ready for
165 | // the next execution to happen
166 | function isSubscriptionReady(
167 | address from, //the subscriber
168 | address to, //the publisher
169 | address tokenAddress, //the token address paid to the publisher
170 | uint256 tokenAmount, //the token amount paid to the publisher
171 | uint256 periodSeconds, //the period in seconds between payments
172 | uint256 gasPrice, //the amount of the token to incentivize the relay network
173 | uint256 nonce,// to allow multiple subscriptions with the same parameters
174 | bytes signature //proof the subscriber signed the meta trasaction
175 | )
176 | public
177 | view
178 | returns (bool)
179 | {
180 | bytes32 subscriptionHash = getSubscriptionHash(
181 | from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce
182 | );
183 | address signer = getSubscriptionSigner(subscriptionHash, signature);
184 | uint256 allowance = ERC20(tokenAddress).allowance(from, address(this));
185 | uint256 balance = ERC20(tokenAddress).balanceOf(from);
186 |
187 | return (
188 | signer == from &&
189 | from != to &&
190 | block.timestamp >= nextValidTimestamp[subscriptionHash] &&
191 | allowance >= tokenAmount.add(gasPrice) &&
192 | balance >= tokenAmount.add(gasPrice)
193 | );
194 | }
195 |
196 | // you don't really need this if you are using the approve/transferFrom method
197 | // because you control the flow of tokens by approving this contract address,
198 | // but to make the contract an extensible example for later user I'll add this
199 | function cancelSubscription(
200 | address from, //the subscriber
201 | address to, //the publisher
202 | address tokenAddress, //the token address paid to the publisher
203 | uint256 tokenAmount, //the token amount paid to the publisher
204 | uint256 periodSeconds, //the period in seconds between payments
205 | uint256 gasPrice, //the amount of tokens or eth to pay relayer (0 for free)
206 | uint256 nonce, //to allow multiple subscriptions with the same parameters
207 | bytes signature //proof the subscriber signed the meta trasaction
208 | )
209 | external
210 | returns (bool success)
211 | {
212 | bytes32 subscriptionHash = getSubscriptionHash(
213 | from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce
214 | );
215 | address signer = getSubscriptionSigner(subscriptionHash, signature);
216 |
217 | //the signature must be valid
218 | require(signer == from, "Invalid Signature for subscription cancellation");
219 |
220 | //make sure it's the subscriber
221 | require(from == msg.sender, 'msg.sender is not the subscriber');
222 |
223 | //nextValidTimestamp should be a timestamp that will never
224 | //be reached during the brief window human existence
225 | nextValidTimestamp[subscriptionHash]=uint256(-1);
226 |
227 | emit CancelSubscription(
228 | from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce
229 | );
230 |
231 | return true;
232 | }
233 |
234 | // execute the transferFrom to pay the publisher from the subscriber
235 | // the subscriber has full control by approving this contract an allowance
236 | function executeSubscription(
237 | address from, //the subscriber
238 | address to, //the publisher
239 | address tokenAddress, //the token address paid to the publisher
240 | uint256 tokenAmount, //the token amount paid to the publisher
241 | uint256 periodSeconds, //the period in seconds between payments
242 | uint256 gasPrice, //the amount of tokens or eth to pay relayer (0 for free)
243 | uint256 nonce, // to allow multiple subscriptions with the same parameters
244 | bytes signature //proof the subscriber signed the meta trasaction
245 | )
246 | public
247 | returns (bool success)
248 | {
249 | bytes32 subscriptionHash = getSubscriptionHash(
250 | from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce
251 | );
252 |
253 | // make sure the subscription is valid and ready
254 | require( isSubscriptionReady(from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce, signature), "Subscription is not ready or conditions of transction are not met" );
255 |
256 | //increment the timestamp by the period so it wont be valid until then
257 | nextValidTimestamp[subscriptionHash] = block.timestamp.add(periodSeconds);
258 |
259 | //check to see if this nonce is larger than the current count and we'll set that for this 'from'
260 | if(nonce > extraNonce[from]){
261 | extraNonce[from] = nonce;
262 | }
263 |
264 | // now, let make the transfer from the subscriber to the publisher
265 | uint256 startingBalance = ERC20(tokenAddress).balanceOf(to);
266 | ERC20(tokenAddress).transferFrom(from,to,tokenAmount);
267 | require(
268 | (startingBalance+tokenAmount) == ERC20(tokenAddress).balanceOf(to),
269 | "ERC20 Balance did not change correctly"
270 | );
271 |
272 | require(
273 | checkSuccess(),
274 | "Subscription::executeSubscription TransferFrom failed"
275 | );
276 |
277 |
278 | emit ExecuteSubscription(
279 | from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce
280 | );
281 |
282 | // it is possible for the subscription execution to be run by a third party
283 | // incentivized in the terms of the subscription with a gasPrice of the tokens
284 | // - pay that out now...
285 | if (gasPrice > 0) {
286 | //the relayer is incentivized by a little of the same token from
287 | // the subscriber ... as far as the subscriber knows, they are
288 | // just sending X tokens to the publisher, but the publisher can
289 | // choose to send Y of those X to a relayer to run their transactions
290 | // the publisher will receive X - Y tokens
291 | // this must all be setup in the constructor
292 | // if not, the subscriber chooses all the params including what goes
293 | // to the publisher and what goes to the relayer
294 | ERC20(tokenAddress).transferFrom(from, msg.sender, gasPrice);
295 | require(
296 | checkSuccess(),
297 | "Subscription::executeSubscription Failed to pay gas as from account"
298 | );
299 | }
300 |
301 | return true;
302 | }
303 |
304 | // because of issues with non-standard erc20s the transferFrom can always return false
305 | // to fix this we run it and then check the return of the previous function:
306 | // https://github.com/ethereum/solidity/issues/4116
307 | /**
308 | * Checks the return value of the previous function. Returns true if the previous function
309 | * function returned 32 non-zero bytes or returned zero bytes.
310 | */
311 | function checkSuccess(
312 | )
313 | private
314 | pure
315 | returns (bool)
316 | {
317 | uint256 returnValue = 0;
318 |
319 | /* solium-disable-next-line security/no-inline-assembly */
320 | assembly {
321 | // check number of bytes returned from last function call
322 | switch returndatasize
323 |
324 | // no bytes returned: assume success
325 | case 0x0 {
326 | returnValue := 1
327 | }
328 |
329 | // 32 bytes returned: check if non-zero
330 | case 0x20 {
331 | // copy 32 bytes into scratch space
332 | returndatacopy(0x0, 0x0, 0x20)
333 |
334 | // load those bytes into returnValue
335 | returnValue := mload(0x0)
336 | }
337 |
338 | // not sure what was returned: dont mark as success
339 | default { }
340 | }
341 |
342 | return returnValue != 0;
343 | }
344 |
345 | //we would like a way for the author to completly destroy the subscription
346 | // contract to prevent further transfers
347 | function endContract()
348 | external
349 | {
350 | require(msg.sender==author);
351 | selfdestruct(author);
352 | }
353 |
354 | // let's go ahead and revert any ETH sent directly to the contract
355 | function () public payable {
356 | revert ();
357 | }
358 | }
359 |
--------------------------------------------------------------------------------
/WasteCoin/WasteCoin.compiled:
--------------------------------------------------------------------------------
1 | pragma solidity ^0.4.24;
2 |
3 | /*
4 | TEST token for tokensubscription.com
5 | */
6 |
7 |
8 |
9 |
10 |
11 | /**
12 | * @title ERC20 interface
13 | * @dev see https://github.com/ethereum/EIPs/issues/20
14 | */
15 | interface IERC20 {
16 | function totalSupply() external view returns (uint256);
17 |
18 | function balanceOf(address who) external view returns (uint256);
19 |
20 | function allowance(address owner, address spender)
21 | external view returns (uint256);
22 |
23 | function transfer(address to, uint256 value) external returns (bool);
24 |
25 | function approve(address spender, uint256 value)
26 | external returns (bool);
27 |
28 | function transferFrom(address from, address to, uint256 value)
29 | external returns (bool);
30 |
31 | event Transfer(
32 | address indexed from,
33 | address indexed to,
34 | uint256 value
35 | );
36 |
37 | event Approval(
38 | address indexed owner,
39 | address indexed spender,
40 | uint256 value
41 | );
42 | }
43 |
44 |
45 |
46 | /**
47 | * @title SafeMath
48 | * @dev Math operations with safety checks that revert on error
49 | */
50 | library SafeMath {
51 |
52 | /**
53 | * @dev Multiplies two numbers, reverts on overflow.
54 | */
55 | function mul(uint256 a, uint256 b) internal pure returns (uint256) {
56 | // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
57 | // benefit is lost if 'b' is also tested.
58 | // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
59 | if (a == 0) {
60 | return 0;
61 | }
62 |
63 | uint256 c = a * b;
64 | require(c / a == b);
65 |
66 | return c;
67 | }
68 |
69 | /**
70 | * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
71 | */
72 | function div(uint256 a, uint256 b) internal pure returns (uint256) {
73 | require(b > 0); // Solidity only automatically asserts when dividing by 0
74 | uint256 c = a / b;
75 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold
76 |
77 | return c;
78 | }
79 |
80 | /**
81 | * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
82 | */
83 | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
84 | require(b <= a);
85 | uint256 c = a - b;
86 |
87 | return c;
88 | }
89 |
90 | /**
91 | * @dev Adds two numbers, reverts on overflow.
92 | */
93 | function add(uint256 a, uint256 b) internal pure returns (uint256) {
94 | uint256 c = a + b;
95 | require(c >= a);
96 |
97 | return c;
98 | }
99 |
100 | /**
101 | * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
102 | * reverts when dividing by zero.
103 | */
104 | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
105 | require(b != 0);
106 | return a % b;
107 | }
108 | }
109 |
110 |
111 |
112 | /**
113 | * @title Standard ERC20 token
114 | *
115 | * @dev Implementation of the basic standard token.
116 | * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
117 | * Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
118 | */
119 | contract ERC20 is IERC20 {
120 | using SafeMath for uint256;
121 |
122 | mapping (address => uint256) private _balances;
123 |
124 | mapping (address => mapping (address => uint256)) private _allowed;
125 |
126 | uint256 private _totalSupply;
127 |
128 | /**
129 | * @dev Total number of tokens in existence
130 | */
131 | function totalSupply() public view returns (uint256) {
132 | return _totalSupply;
133 | }
134 |
135 | /**
136 | * @dev Gets the balance of the specified address.
137 | * @param owner The address to query the the balance of.
138 | * @return An uint256 representing the amount owned by the passed address.
139 | */
140 | function balanceOf(address owner) public view returns (uint256) {
141 | return _balances[owner];
142 | }
143 |
144 | /**
145 | * @dev Function to check the amount of tokens that an owner allowed to a spender.
146 | * @param owner address The address which owns the funds.
147 | * @param spender address The address which will spend the funds.
148 | * @return A uint256 specifying the amount of tokens still available for the spender.
149 | */
150 | function allowance(
151 | address owner,
152 | address spender
153 | )
154 | public
155 | view
156 | returns (uint256)
157 | {
158 | return _allowed[owner][spender];
159 | }
160 |
161 | /**
162 | * @dev Transfer token for a specified address
163 | * @param to The address to transfer to.
164 | * @param value The amount to be transferred.
165 | */
166 | function transfer(address to, uint256 value) public returns (bool) {
167 | require(value <= _balances[msg.sender]);
168 | require(to != address(0));
169 |
170 | _balances[msg.sender] = _balances[msg.sender].sub(value);
171 | _balances[to] = _balances[to].add(value);
172 | emit Transfer(msg.sender, to, value);
173 | return true;
174 | }
175 |
176 | /**
177 | * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
178 | * Beware that changing an allowance with this method brings the risk that someone may use both the old
179 | * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
180 | * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
181 | * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
182 | * @param spender The address which will spend the funds.
183 | * @param value The amount of tokens to be spent.
184 | */
185 | function approve(address spender, uint256 value) public returns (bool) {
186 | require(spender != address(0));
187 |
188 | _allowed[msg.sender][spender] = value;
189 | emit Approval(msg.sender, spender, value);
190 | return true;
191 | }
192 |
193 | /**
194 | * @dev Transfer tokens from one address to another
195 | * @param from address The address which you want to send tokens from
196 | * @param to address The address which you want to transfer to
197 | * @param value uint256 the amount of tokens to be transferred
198 | */
199 | function transferFrom(
200 | address from,
201 | address to,
202 | uint256 value
203 | )
204 | public
205 | returns (bool)
206 | {
207 | <<<<<<< HEAD
208 | require(value <= _allowed[from][msg.sender]);
209 |
210 | _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
211 | _transfer(from, to, value);
212 | =======
213 | require(value <= _balances[from]);
214 | require(value <= _allowed[from][msg.sender]);
215 | require(to != address(0));
216 |
217 | _balances[from] = _balances[from].sub(value);
218 | _balances[to] = _balances[to].add(value);
219 | _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
220 | emit Transfer(from, to, value);
221 | >>>>>>> 409679cb641f5bcaa76d81d090b97dca4e00bddf
222 | return true;
223 | }
224 |
225 | /**
226 | * @dev Increase the amount of tokens that an owner allowed to a spender.
227 | * approve should be called when allowed_[_spender] == 0. To increment
228 | * allowed value is better to use this function to avoid 2 calls (and wait until
229 | * the first transaction is mined)
230 | * From MonolithDAO Token.sol
231 | * @param spender The address which will spend the funds.
232 | * @param addedValue The amount of tokens to increase the allowance by.
233 | */
234 | function increaseAllowance(
235 | address spender,
236 | uint256 addedValue
237 | )
238 | public
239 | returns (bool)
240 | {
241 | require(spender != address(0));
242 |
243 | _allowed[msg.sender][spender] = (
244 | _allowed[msg.sender][spender].add(addedValue));
245 | emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
246 | return true;
247 | }
248 |
249 | /**
250 | * @dev Decrease the amount of tokens that an owner allowed to a spender.
251 | * approve should be called when allowed_[_spender] == 0. To decrement
252 | * allowed value is better to use this function to avoid 2 calls (and wait until
253 | * the first transaction is mined)
254 | * From MonolithDAO Token.sol
255 | * @param spender The address which will spend the funds.
256 | * @param subtractedValue The amount of tokens to decrease the allowance by.
257 | */
258 | function decreaseAllowance(
259 | address spender,
260 | uint256 subtractedValue
261 | )
262 | public
263 | returns (bool)
264 | {
265 | require(spender != address(0));
266 |
267 | _allowed[msg.sender][spender] = (
268 | _allowed[msg.sender][spender].sub(subtractedValue));
269 | emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
270 | return true;
271 | }
272 |
273 | /**
274 | <<<<<<< HEAD
275 | * @dev Transfer token for a specified addresses
276 | * @param from The address to transfer from.
277 | * @param to The address to transfer to.
278 | * @param value The amount to be transferred.
279 | */
280 | function _transfer(address from, address to, uint256 value) internal {
281 | require(value <= _balances[from]);
282 | require(to != address(0));
283 |
284 | _balances[from] = _balances[from].sub(value);
285 | _balances[to] = _balances[to].add(value);
286 | emit Transfer(from, to, value);
287 | }
288 |
289 | /**
290 | =======
291 | >>>>>>> 409679cb641f5bcaa76d81d090b97dca4e00bddf
292 | * @dev Internal function that mints an amount of the token and assigns it to
293 | * an account. This encapsulates the modification of balances such that the
294 | * proper events are emitted.
295 | * @param account The account that will receive the created tokens.
296 | * @param amount The amount that will be created.
297 | */
298 | function _mint(address account, uint256 amount) internal {
299 | require(account != 0);
300 | _totalSupply = _totalSupply.add(amount);
301 | _balances[account] = _balances[account].add(amount);
302 | emit Transfer(address(0), account, amount);
303 | }
304 |
305 | /**
306 | * @dev Internal function that burns an amount of the token of a given
307 | * account.
308 | * @param account The account whose tokens will be burnt.
309 | * @param amount The amount that will be burnt.
310 | */
311 | function _burn(address account, uint256 amount) internal {
312 | require(account != 0);
313 | require(amount <= _balances[account]);
314 |
315 | _totalSupply = _totalSupply.sub(amount);
316 | _balances[account] = _balances[account].sub(amount);
317 | emit Transfer(account, address(0), amount);
318 | }
319 |
320 | /**
321 | * @dev Internal function that burns an amount of the token of a given
322 | * account, deducting from the sender's allowance for said account. Uses the
323 | * internal burn function.
324 | * @param account The account whose tokens will be burnt.
325 | * @param amount The amount that will be burnt.
326 | */
327 | function _burnFrom(address account, uint256 amount) internal {
328 | require(amount <= _allowed[account][msg.sender]);
329 |
330 | // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
331 | // this function needs to emit an event with the updated approval.
332 | _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
333 | amount);
334 | _burn(account, amount);
335 | }
336 | }
337 |
338 |
339 |
340 |
341 | /**
342 | * @title Roles
343 | * @dev Library for managing addresses assigned to a Role.
344 | */
345 | library Roles {
346 | struct Role {
347 | mapping (address => bool) bearer;
348 | }
349 |
350 | /**
351 | * @dev give an account access to this role
352 | */
353 | function add(Role storage role, address account) internal {
354 | require(account != address(0));
355 | role.bearer[account] = true;
356 | }
357 |
358 | /**
359 | * @dev remove an account's access to this role
360 | */
361 | function remove(Role storage role, address account) internal {
362 | require(account != address(0));
363 | role.bearer[account] = false;
364 | }
365 |
366 | /**
367 | * @dev check if an account has this role
368 | * @return bool
369 | */
370 | function has(Role storage role, address account)
371 | internal
372 | view
373 | returns (bool)
374 | {
375 | require(account != address(0));
376 | return role.bearer[account];
377 | }
378 | }
379 |
380 |
381 |
382 | contract MinterRole {
383 | using Roles for Roles.Role;
384 |
385 | event MinterAdded(address indexed account);
386 | event MinterRemoved(address indexed account);
387 |
388 | Roles.Role private minters;
389 |
390 | constructor() public {
391 | <<<<<<< HEAD
392 | _addMinter(msg.sender);
393 | =======
394 | minters.add(msg.sender);
395 | >>>>>>> 409679cb641f5bcaa76d81d090b97dca4e00bddf
396 | }
397 |
398 | modifier onlyMinter() {
399 | require(isMinter(msg.sender));
400 | _;
401 | }
402 |
403 | function isMinter(address account) public view returns (bool) {
404 | return minters.has(account);
405 | }
406 |
407 | function addMinter(address account) public onlyMinter {
408 | <<<<<<< HEAD
409 | _addMinter(account);
410 | }
411 |
412 | function renounceMinter() public {
413 | _removeMinter(msg.sender);
414 | }
415 |
416 | function _addMinter(address account) internal {
417 | minters.add(account);
418 | emit MinterAdded(account);
419 | =======
420 | minters.add(account);
421 | emit MinterAdded(account);
422 | }
423 |
424 | function renounceMinter() public {
425 | minters.remove(msg.sender);
426 | >>>>>>> 409679cb641f5bcaa76d81d090b97dca4e00bddf
427 | }
428 |
429 | function _removeMinter(address account) internal {
430 | minters.remove(account);
431 | emit MinterRemoved(account);
432 | }
433 | }
434 |
435 |
436 |
437 | /**
438 | * @title ERC20Mintable
439 | * @dev ERC20 minting logic
440 | */
441 | contract ERC20Mintable is ERC20, MinterRole {
442 | <<<<<<< HEAD
443 | =======
444 | event MintingFinished();
445 |
446 | bool private _mintingFinished = false;
447 |
448 | modifier onlyBeforeMintingFinished() {
449 | require(!_mintingFinished);
450 | _;
451 | }
452 |
453 | /**
454 | * @return true if the minting is finished.
455 | */
456 | function mintingFinished() public view returns(bool) {
457 | return _mintingFinished;
458 | }
459 |
460 | >>>>>>> 409679cb641f5bcaa76d81d090b97dca4e00bddf
461 | /**
462 | * @dev Function to mint tokens
463 | * @param to The address that will receive the minted tokens.
464 | * @param amount The amount of tokens to mint.
465 | * @return A boolean that indicates if the operation was successful.
466 | */
467 | function mint(
468 | address to,
469 | uint256 amount
470 | )
471 | public
472 | onlyMinter
473 | <<<<<<< HEAD
474 | =======
475 | onlyBeforeMintingFinished
476 | >>>>>>> 409679cb641f5bcaa76d81d090b97dca4e00bddf
477 | returns (bool)
478 | {
479 | _mint(to, amount);
480 | return true;
481 | }
482 | <<<<<<< HEAD
483 | =======
484 |
485 | /**
486 | * @dev Function to stop minting new tokens.
487 | * @return True if the operation was successful.
488 | */
489 | function finishMinting()
490 | public
491 | onlyMinter
492 | onlyBeforeMintingFinished
493 | returns (bool)
494 | {
495 | _mintingFinished = true;
496 | emit MintingFinished();
497 | return true;
498 | }
499 | >>>>>>> 409679cb641f5bcaa76d81d090b97dca4e00bddf
500 | }
501 |
502 |
503 | contract WasteCoin is ERC20Mintable {
504 |
505 | string public name = "WasteCoin";
506 | string public symbol = "WC";
507 | uint8 public decimals = 18;
508 |
509 | constructor() public { }
510 |
511 | }
512 |
--------------------------------------------------------------------------------
/grants/src/App.js:
--------------------------------------------------------------------------------
1 | import React, { Component } from 'react';
2 | import { BrowserRouter as Router, Route } from "react-router-dom";
3 | import { Metamask, Gas, ContractLoader, Transactions, Button, Scaler } from "dapparatus"
4 | import RLP from 'rlp';
5 | import axios from 'axios'
6 | import Web3 from 'web3';
7 | import './App.css';
8 |
9 | import Coins from './coins.js'
10 | import Nav from './components/Nav';
11 | import Home from './components/Home';
12 | import GrantsList from './components/GrantsList';
13 | import CreateGrants from './components/CreateGrants';
14 | import GrantDetails from './components/GrantDetails';
15 |
16 |
17 | let backendUrl = ""
18 | let setBackendUrl = (network)=>{
19 | backendUrl = "http://localhost:10003/"
20 | if(network == "Rinkeby"){
21 | backendUrl = "https://rinkeby.tokensubscription.com/"
22 | }
23 | else if(window.location.href.indexOf("tokensubscription.com")>=0 || window.location.href.indexOf("ethgrants.com")>=0)
24 | {
25 | backendUrl = "https://relay.tokensubscription.com/"
26 | }
27 |
28 | }
29 |
30 | class App extends Component {
31 | constructor(props) {
32 | super(props);
33 | console.log("Firing up with backendUrl:"+backendUrl)
34 | this.state = {
35 | grantToAddress:"0x0000000000000000000000000000000000000000",
36 | toAddress:"0x0000000000000000000000000000000000000000",
37 | author:"0x0000000000000000000000000000000000000000",
38 | web3: false,
39 | account: false,
40 | gwei: 4,
41 | title: '',
42 | pitch: '',
43 | desc: '# This is a preview',
44 | deploying: false,
45 | contractAddress: false,
46 | deployingGrantContract: false,
47 | ///SUBSCRIBE DEFUALTS:
48 | tokenAmount: 10,
49 | timeAmount: 1,
50 | timeType:"months",
51 | tokenAddress:"0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359",
52 | gasPrice:0.25,
53 | tokenName:"DAI",
54 | }
55 |
56 | this.handleInput = this.handleInput.bind(this)
57 | this.deployGrantContract = this.deployGrantContract.bind(this)
58 | this.sendSubscription = this.sendSubscription.bind(this)
59 | this.submitGrant = this.submitGrant.bind(this)
60 | }
61 | componentDidMount(){
62 | let priceQuery = "https://min-api.cryptocompare.com/data/pricemulti?fsyms=ETH,DAI,ZRX,BAT,REP,GNT,SNT,BNT,MANA&tsyms=USD&extraParams=ethgrantscom"
63 | console.log("Loading prices...",priceQuery)
64 | axios.get(priceQuery)
65 | .then((response) =>{
66 | let data = response.data;
67 | data.WC = {USD: 1} //add our fake coin in to test
68 | this.setState({prices:data},()=>{
69 | console.log("PRICES SET:",this.state.prices)
70 | })
71 | console.log("priceQuery",response);
72 | })
73 | .catch(function (error) {
74 | console.log("priceQuery",error);
75 | })
76 | }
77 |
78 | async sendSubscription(){
79 | let {toAddress,timeType,tokenAmount,tokenAddress,gasPrice,account,web3} = this.state
80 |
81 | let tokenContract = this.state.customContractLoader("WasteCoin",tokenAddress)
82 | let subscriptionContract = this.state.customContractLoader("Subscription",this.state.deployedAddress)
83 |
84 | let value = 0
85 | let txData = "0x02" //something like this to say, hardcoded VERSION 2, we're sending approved tokens
86 | let gasLimit = 120000
87 |
88 | //hardcode period seconds to monthly
89 | let periodSeconds=2592000
90 | if(!gasPrice) gasPrice = 0
91 |
92 | console.log("TOKEN CONTRACT ",tokenContract)
93 | let decimals = parseInt(await tokenContract.decimals().call())
94 | console.log("decimals",decimals)
95 |
96 | let nonce = parseInt(await subscriptionContract.extraNonce(account).call())+1
97 |
98 | let realTokenAmount = tokenAmount*10**decimals
99 | let realGasPrice = gasPrice*10**decimals
100 | /*
101 | address from, //the subscriber
102 | address to, //the publisher
103 | address tokenAddress, //the token address paid to the publisher
104 | uint256 tokenAmount, //the token amount paid to the publisher
105 | uint256 periodSeconds, //the period in seconds between payments
106 | uint256 gasPrice, //the amount of tokens or eth to pay relayer (0 for free)
107 | */
108 |
109 | const parts = [
110 | account,
111 | toAddress,
112 | tokenAddress,
113 | web3.utils.toTwosComplement(realTokenAmount),
114 | web3.utils.toTwosComplement(periodSeconds),
115 | web3.utils.toTwosComplement(realGasPrice),
116 | web3.utils.toTwosComplement(nonce)
117 | ]
118 | /*web3.utils.padLeft("0x"+nonce,64),*/
119 | console.log("PARTS",parts)
120 |
121 | const subscriptionHash = await subscriptionContract.getSubscriptionHash(...parts).call()
122 | console.log("subscriptionHash",subscriptionHash)
123 |
124 |
125 | let signature = await web3.eth.personal.sign(""+subscriptionHash,account)
126 | console.log("signature",signature)
127 | let postData = {
128 | subscriptionContract:this.state.deployedAddress,
129 | parts:parts,
130 | subscriptionHash: subscriptionHash,
131 | signature:signature,
132 | }
133 |
134 | console.log("postData",postData)
135 | axios.post(backendUrl+'saveSubscription', postData, {
136 | headers: {
137 | 'Content-Type': 'application/json',
138 | }
139 | }).then((response)=>{
140 | console.log("TX RESULT",response.data.subscriptionHash)
141 | })
142 | .catch((error)=>{
143 | console.log(error);
144 | });
145 | }
146 |
147 |
148 | async deployGrantContract(grantToAddress,tokenName,tokenAmount,timeType,timeAmount,gasPrice,email) {
149 | let {web3,tx,contracts} = this.state
150 |
151 | if(!web3){
152 | alert("Please install and unlock web3. (MetaMask, Trust, etc)")
153 | }else{
154 |
155 | //requiredToAddress,requiredTokenAddress,requiredTokenAmount,requiredPeriodSeconds,requiredGasPrice
156 | let requiredToAddress = "0x0000000000000000000000000000000000000000"
157 | if(grantToAddress){
158 | requiredToAddress = grantToAddress
159 | }
160 |
161 | let foundToken
162 | let requiredTokenAddress = "0x0000000000000000000000000000000000000000"
163 | if(tokenName){
164 | //translate tokenName to tokenAddress
165 | for(let i = 0; i < this.state.coins.length; i++){
166 | if(tokenName == this.state.coins[i].address){
167 | requiredTokenAddress = this.state.coins[i].address
168 | foundToken = this.state.coins[i]
169 | }
170 | }
171 | }
172 |
173 | let requiredPeriodSeconds=0
174 | if(timeAmount){
175 | //translate timeAmount&timeType to requiredPeriodSeconds
176 | let periodSeconds = timeAmount;
177 | if(timeType=="minutes"){
178 | periodSeconds*=60
179 | }else if(timeType=="hours"){
180 | periodSeconds*=3600
181 | }else if(timeType=="days"){
182 | periodSeconds*=86400
183 | }else if(timeType=="months"){
184 | periodSeconds*=2592000
185 | }
186 | if(periodSeconds){
187 | requiredPeriodSeconds=periodSeconds
188 | }
189 | }
190 |
191 | let requiredTokenAmount=0
192 | let requiredGasPrice=0
193 | if(tokenAmount && foundToken){
194 | //don't forget decimals.. you do a number * (10**##DECIMALS##)
195 | requiredTokenAmount = tokenAmount * (10**foundToken.decimals)
196 | if(gasPrice && foundToken){
197 | //don't forget decimals.. you do a number * (10**##DECIMALS##)
198 | requiredGasPrice = gasPrice * (10**foundToken.decimals)
199 | requiredTokenAmount -= requiredGasPrice
200 | }
201 | }
202 |
203 |
204 | console.log("we can guess what the contract address is going to be, this let's us get the UI going without it being deployed yet...")
205 | let txCount = await this.state.web3.eth.getTransactionCount(this.state.account,'pending')
206 | let deployingAddress = "0x"+this.state.web3.utils.keccak256(RLP.encode([this.state.account,txCount])).substr(26)
207 | this.setState({deployingAddress:deployingAddress})
208 |
209 | console.log("Deploying Subscription Contract...")
210 | let code = require("./contracts/Subscription.bytecode.js")
211 |
212 | let args = [
213 | requiredToAddress,
214 | requiredTokenAddress,
215 | web3.utils.toTwosComplement(requiredTokenAmount),
216 | web3.utils.toTwosComplement(requiredPeriodSeconds),
217 | web3.utils.toTwosComplement(requiredGasPrice)
218 | ]
219 |
220 | console.log("ARGS",args)
221 |
222 | this.setState({deployingGrantContract:true})
223 |
224 | tx(contracts.Subscription._contract.deploy({data:code,arguments:args}),1500000,(receipt)=>{
225 | console.log("~~~~~~ DEPLOY FROM DAPPARATUS:",receipt)
226 | if(receipt.contractAddress){
227 | console.log("CONTRACT DEPLOYED:",receipt.contractAddress)
228 | this.setState({deployedAddress:receipt.contractAddress,deployingGrantContract:false})
229 | }
230 | })
231 |
232 | axios.post(backendUrl+'deploysub',{arguments:args,email:email,deployingAddress:deployingAddress}, {
233 | headers: {
234 | 'Content-Type': 'application/json',
235 | }
236 | }).then((response)=>{
237 | console.log("SAVED INFO:",response.data)
238 |
239 | })
240 | .catch((error)=>{
241 | console.log(error);
242 | });
243 | }
244 | }
245 | submitGrant(hash,sig){
246 | let {title,pitch,deployedAddress,desc,monthlyGoal,grantDuration,contactName,contactEmail} = this.state
247 | axios.post(backendUrl+'grants/create',{hash,sig,title,pitch,deployedAddress,desc,monthlyGoal,grantDuration,contactName,contactEmail}, {
248 | headers: {
249 | 'Content-Type': 'application/json',
250 | }
251 | }).then((response)=>{
252 | console.log("SAVED INFO:: ",response.data)
253 | if(response.data.updateId){
254 | window.location = "/view/"+response.data.updateId
255 | }else{
256 | window.location = "/view/"+response.data.insertId
257 | }
258 |
259 | })
260 | .catch((error)=>{
261 | console.log(error);
262 | });
263 | }
264 |
265 | handleInput(e,data){
266 | let update = {}
267 | if(data){
268 | update[data.name] = data.value
269 | }else{
270 | let value = e.target.value
271 | if(e.target.name=="title") value = value.substring(0,148) //limit title characters
272 | if(e.target.name=="pitch") value = value.substring(0,298) //limit pitch characters
273 | update[e.target.name] = value
274 | }
275 | this.setState(() => (update));
276 | }
277 |
278 | save(state,cb){
279 | this.setState(state,cb)
280 | }
281 |
282 | render() {
283 | //console.log(this.state.title)
284 | let {web3,account,contracts,tx,gwei,block,avgBlockTime,etherscan} = this.state
285 | //console.log(this.state)
286 | let extraRoutes = ""
287 | let connectedDisplay = []
288 | if(web3){
289 | extraRoutes = (
290 | Loading Contract...
372 |
291 | {
292 | return {
303 | return
313 | )
314 | connectedDisplay.push(
315 |
372 | {
373 | return (
374 |
375 | )
376 | }} />
377 | {
378 | return (
379 |
380 | )
381 | }} />
382 |
383 | )
384 | }
385 | return (
386 | Please Unlock MetaMask
Please Unlock MetaMask
388 | {
401 | console.log("metamask state update:",state)
402 | this.setState({grantToAddress:state.account},()=>{
403 | console.log("grantToAddress:",this.state.grantToAddress)
404 | })
405 | if(state.web3Provider) {
406 | state.web3 = new Web3(state.web3Provider)
407 | console.log("WEB3",state)
408 | setBackendUrl(state.network)
409 | console.log("backendUrl",backendUrl)
410 | this.setState(state)
411 | }
412 | }}
413 | />
414 | {connectedDisplay}
415 |
416 |
417 |
418 |
422 |