😎 Cheat Sheet

One-liners to keep you "in the flow".

Quick-start

Setup the SDK in Truffle console and mint DAIx. See the tutorial for a full walk-through.

Tokens

balanceOf()

(await daix.balanceOf(bob)).toString() / 1e18
(await dai.balanceOf(bob)).toString() / 1e18
​
or
​
(async () => wad4human(await dai.balanceOf(bob))()
(async () => wad4human(await daix.balanceOf(bob))()

upgrade()

dai.approve(daix.address, "1" + "0".repeat(42), { from: bob });
daix.upgrade(web3.utils.toWei("50", "ether"), { from: bob });

User Class

user()

const bob = sf.user({ address: bobAddress, token: daix.address });
const alice = sf.user({ address: aliceAddress, token: daix.address });

bob.details()

const details = await bob.details();
​
// returns an object
details: {
cfa: {
flows: {
inFlows: [
{ sender, receiver, flowRate }
],
outFlows: [
{ sender, receiver, flowRate }
]
},
netFlow: ""
}
ida: {
subscriptions: []
}

Agreements

Constant Flow Agreement (CFA)

A CFA is a transfer of value from a sender to a receiver at a constant flowRate measured in amount per second.

User Class (easy mode)

bob.flow()

// create new flow
bob.flow({ recipient: alice, flowRate: "-38580246913580" }); //recipient can be user object or address
​
// edit existing flow
bob.flow({ recipient: alice.address, flowRate: 0.1 * 1e18 }); //0.1 DAI per second with 18 decimals.
​
// close flow
bob.flow({ recipient: alice, flowRate: "0" });
​
// add custom userData parameters
const userData = { message: "here's a flow Alice", flowId: "007" };
bob.flow({ recipient: alice, flowRate: 1 * 1e18, options: { userData } });

Agreement Helper Class (hard mode)

createFlow()

sf.cfa.createFlow({
superToken: daix.address,
sender: bob,
receiver: alice,
flowRate: "385802469135802"
});

updateFlow()

sf.cfa.createFlow({
superToken: daix.address,
sender: bob,
receiver: alice,
flowRate: "632802469135333"
});

deleteFlow()

sf.cfa.deleteFlow({superToken: daix.address, sender: bob, receiver: alice, by: bob})

getNetFlow()

(await sf.cfa.getNetFlow({superToken: daix.address, account: bob})).toString()

getFlow()

(await sf.cfa.getFlow({superToken: daix.address, sender: bob, receiver: alice})).toString()

listFlows()

await sf.cfa.listFlows({superToken: daix.address, account: bob})

Instant Distribution Agreement (IDA)

An IDA is used to send funds as one-time-payments. It consists of a Publishing Index with indexId, an indexValue which is updated every time distribute() is called, and one or more subscribers.

Remember there is one distributor, and many subscribers.

User Class (easy mode)

bob.createPool()

await bob.createPool({ poolId: 1 });

bob.giveShares()

await bob.giveShares({ poolId: 1, recipient: alice, shares: 90 });
await bob.giveShares({ poolId: 1, recipient: carol, shares: 10 });

bob.distributeToPool()

await bob.distributeToPool({ poolId: 1, amount: 1000 });

Agreement Helper Class (hard mode)

createIndex() (sent from publisher)

sf.ida.createIndex({
superToken: daix.address,
indexId: 1,
sender: bob.address
});

updateSubscription() (sent from publisher)

sf.ida.updateSubscription({
superToken: daix.address,
indexId: 1,
subscriber: carol.address, //who is receiving the units
sender: bob.address, //the publisher
units: "100"
});

approveSubscription() (sent from subscriber)

sf.ida.approveSubscription({
superToken: daix.address,
indexId: 1,
publisher: bob.address, // the publisher
sender: carol.address // who is receiving the units and sending this tx
});

distribute() (sent from publisher)

sf.ida.distribute({
superToken: daix.address,
indexId: 1,
amount: 100 * 1e18, // amount to distribute
sender: bob.address // the Publisher
});

claim() (sent from subscriber)

sf.ida.claim({
superToken: daix.address,
publisher: bob.address,
indexId: 1,
subscriber: carol.address,
sender: carol.address // because ANYONE can send this tx
});

​

​