The goal of this project is to incentivize XR adoption in the best possible way we can imagine: open-source and on-chain.
The economics of this are possible. By combining WebVR, AR.js, and HIVE, we buildd a platform free for everyone to use that rewards good content with real cryptocurrency you can spend or transfer.
We recognize that in order for vr to take off, its creation needs to reach a point of enabling everyone to participate, so we lowered the barrier to entry as far as we possibly could.
Remix our Glitch projects to immediately begin building experiences that earn you rewards by publishing to Steem. Experiences that run on nearly any device, computer, and head mounted display through the web browser.
Deploy your next game, video, or experience at no cost with no programming expertise. We'll show you how.
Quickstart
We've made it easy to get up and running by integrating all the technical stuff so you can start creating right away!
To fully utilize our platform, you must have a HIVE account. It can take some time for your account to activate, but you can start building apps immediately.
FAQ
Find answers to Frequently Asked Questions
Whitepaper
The original dlux whitepaper was written by Steven Ettinger and Mark Giles.
It details the philosophy and design principles behind the dlux-io platform. Back then, HIVE was called STEEM.
If pictures are more your thing, check out the Slide Deck instead.
Supercraft VR Publishing
DLUX Glitch VR Boilerplate
dlux Builder is integrated with Glitch for free & easy remixing, prototyping, and publishing.
Add 3D Model
Models must be in glTF format (unpacked .gltf, embedded .gltf, binary .glb), Use blackthread.io/gltf-converter to convert other formats to glTF.
Click Add 3D Model
Set your options
Drag-and-drop all required files
Add Images
Max photo resolution is 4096px, and must be in power of 2, such as 512x512px, or 1024x512px (.png or .jpg)
Click Add Images
Set your options
Drag and drop photos (no limit)
If [X] Add to scene is checked, the photos dropped in will be applied to box geometry and inserted into your scene. You can then use the inspector to place the photos in your scene.
Description
Posting to Hive requires a Title, Body, and Tags. This allows your experience to be discovered and enjoyed by others on the network.
Get a Hive Account.
Views
In our Glitch boilerplate you have access to the following views:
Glitch: modify the code in each file of your experience
dlux Builder: adds a toolbar to the Glitch view
Asset Upload: Drag-&-Drop asset well
App View: Live build of your app
Glitch is a collaborative development environment that allows users to quickly duplicate and modify apps. We've built on top of this to offer a social XR boilerplate with drag-and-drop asset upload and Steem publishing.
We recommend creating a Glitch account so you can keep track of all your apps and collaborate easily.
The dlux vr boilerplate is accessible on Glitch here:
On the left you have a Glitch instance which is collaborative, auto-saves, and has the ability to rewind your code.
On the right you have a running version of your app. Changes made to the code on the left are not shown on the right until you click the Refresh App button at the top.
At the bottom is the browsers web inspector.
If you need to edit the Steem post that contains your dApp, such as update the preview images or html, follow these steps:
Ensure you are logged in as the owner of the dApp(the username that posted it)
Navigate to your dapp on dlux.io or localhost
/dlux/@username/permLink in the address bar needs to be changed to /post/edit/@username/permLink
Now you have the screen to change the metadata that is the ipfs reference to your app, as well as the title and blog post.
Press Submit at the bottom and your Hive post will be updated, this action takes Resource Credits.
Once you're happy with how your app is working, you need to generate the preview so others know what they're clicking on.
For the blog, you need a traditional preview image, and for the portal inside dlux that goes to your experience, you need a 360 preview image.
Take a 16x9 traditional photo for the Steem blog entry by pressing Ctl-Alt-S
Take a 360 photo for the portal preview by pressing Ctl-Alt-Shift-S
Advanced App Uploader
Working With 3D Models
A-Frame recommends glTF
glTF is the rising star of 3D asset distribution viewing. In comparison to the older OBJ format, which supports only vertices, normals, texture coordinates, and basic materials, glTF provides a more powerful set of features.
In addition to all of the above, glTF offers:
Hierarchical objects
Scene information (light sources, cameras)
Skeletal structure and animation
More robust materials and shaders
Models can be created or downloaded in glTF:
Sketchup Make 2017 + glTF Exporter is free and great for architecture
Blender 2.8 (beta) is a free, open-source, professional 3D modeling program with glTF export
Blender 2.79 + glTF Exporter if you're not on 2.8 (beta)
Sketchfab has thousands of free MIT license models auto-converted to glTF
Google Poly also has some free downloadable models in glTF
glTF Overview:
Your model should be under 3MB, and can include textures in power of 2 (1024x512). Animations are supported with animation-mixer.
1. Export or download your model as a glTF 2.0:
unpacked .glTF .bin .png .jpg
embedded .glTF
binary .glb
2. Click Add 3D Model in the dlux Builder
Convert png to jpg (beta)
KHR Unlit option (see below)
Pin to IPFS for 6 months (100MB limit)
3. Drag and drop your files
Open the logs if you want to see progress and confirmation of your asset being converted to a binary glTF (if not already in .glb format)
Once your asset is uploaded to IPFS, it will be inserted into A-Frame's asset manager, and placed in your scene at the origin
Your window will refresh with the updated changes
Now you can use the inspector to place your model where you'd like and save the changes back to your scene.
PBR (Lit)
PBR-Lit
KHR (Unlit)
KHR-Unlit 3. Drag and drop your file(s)
Manually tinkering with glTF and OBJ
If you're not using our drag and drop uploader, you may want to better understand inside the files
glTF contains these files
.gltf (model and material information)
.bin (geometry and animation)
.jpg, .png (textures)
OBJ contains these files
.obj (model information)
.mtl (material information)
.jpg, .png (textures)
.gltf, .obj, and .mtl are all text files that can be created in Glitch by clicking the button + New File, while .bin, .jpg, and .png must be uploaded to assets or somewhere. Note anything in your assets folder won't be uploaded to IPFS, it will instead be served from Glitch CDN.
↠assets
Drag in assets you'd like to use, such as glTF .bin files, .jpg or .png texture photos, music .mp3 files, and whatever else is needed to build your scene.
Steps for glTF .bin and texture .jpg or .png files
1. Upload all .bin, .jpg, and .png files to assets
Drag and drop the files into the assets folder in the left sidebar
Copy the URL of each file
2. Paste URL(s) into model containers
glTF:
Open yourmodel.gltf with a word processor and search for "uri"
Update "uri": "model.bin" with the correct URL copied from assets
Update all instances of "uri": "texture.jpg" with the correct URL(s) copied from assets
MTL:
Open yourmodel.mtl with a word processor and search for "map"
Update all instances of map_Kd texture.jpg with the correct URL(s) copied from assets
↠New Files
Click the + New File button in the left sidepanel
Create corresponding files on Glitch
yourmodel.gltf (if using glTF)
yourmodel.obj (if using OBJ)
yourmodel.mtl (if using OBJ)
Open the .gltf, or .obj and .mtl files you downloaded, or created. They can be viewed with any word processor on your desktop
Copy the contents of each file
Paste into the corresponding new file on Glitch index.html
Now that you have either:
an updated .gltf pointing to the .bin and any .jpg or .png textures in assets
an .obj and updated .mtl pointing to any .jpg or .png textures in assets
glTF (GitHub Source)
glTF contains a .bin for geometry and animation data. glTFs and can use texture files, but cannot use A-Frame's material property.
Learn more about using glTF with A-Frame: https://aframe.io/docs/0.8.0/components/gltf-model.html
Textures
Texture files for both OBJ and glTF should be .jpg or .png with a resolution power of 2. This means the following are okay:
1024x1024
1024x2048
512x512
2048x512
2x2 pairs tend to be most optimal.
Animation
https://github.com/donmccurdy/aframe-extras/tree/master/src/loaders#animation
glTF loader example
Working With Images
Images for STEEM and dlux posts.
Posting through dlux includes both traditional 16x9 rectangular images for all front ends, and 360 equirectangular images for portal preview images in VR on dlux.
Capture Images
16x9 Images can be captured inside an A-Frame scene by pressing ctl-alt-s
360 Images can be captured inside an A-Frame scene by pressing ctl-alt-shift-s
Upload Images
Drag and drop your images onto the IPFS uploader
If you want your images to appear in the scene, whether traditional or 360, select the "Add to scene" checkbox. This will create either a box (traditional) or sphere (360) geometry with src set to your uploaded item so it appears in your scene.
The engine prefers images in power of 2 resolution.
This means the resolution should be 2,4,8,16,32,64,128,256,512,1024,2048,etc...
Note the original resolution of your image and append it or a ratio of it to the file name.
Ex. image.jpg is 1000x600px, rename to image_1.6.jpg
Scale your image using Photoshop or something similar.
Ex. scale image_1.6.jpg to 1024x512px
Adding And Manipulating Text
Add font to asset manager
Talk about character wrap
Text geometry is computationally expensive
Adding And Manipulating Shapes
Streaming Audio
Streaming Video
Streaming Video Options
At the moment, video can be streamed from any platform supporting 3rd party players, such as Vimeo Pro or d.tube
Upload your video to d.tube, then
Load Video Assets
All videos should be loaded via the asset manager denoted
You can use traditional 16x9 or 360 videos.
Create an entity with the appropriate geometry (plane, box, sphere) and set its src="#myVideo"
XR Components
The 3D world of dlux is built using WebXR.
We consider WebXR to be based on THREE.js including:
A-Frame, an HTML implementation of WebVR
AR.js, marker-based AR for A-Frame
WebXR-Polyfill, markerless AR built on WebVR
In the future, the WebXR Device API will be available, and will integrate ARKit and ARCore with WebVR.
Environment
Setup an Environment
Environment is a powerful component that allows you to quickly build out landscape and atmosphere for your scene. You do not have to use it, but is an easy way to get started and comes included in dlux!
Presets
A-Frame Environments
Customization
In a dlux A-Frame scene:
Open the inspector by pressing ctl-alt-i
Select the "env" entity in the left side-bar
Select a-entity env
Start with a preset you like, and customize it in right side-bar
When you're happy with it, click the Save button in the left side-bar
Environment Customization Options
active turns the entire component on or off
dressing changes the shape of the dressing objects (trees, pyramids, etc). You can further customize the amount, color, scale, and variance.
flatShading changes the rendered appearance
fog adds atmosphere
grid appears on the floor and can be helpful for layout and design, choose any color.
ground changes the way the geometry of the ground in the distance. Customize the color and texture style to change how the ground is rendered.
horizonColor adjusts the color of the horizon, and the position and type of light can be customized floor appearance, colors, sky type, and lighting.
preset fills all values with those defined by the preset
skyColor adjusts the color of the sky, it's type can be set to color, gradient, or atmosphere.
Working with the code
You can work with the code directly in Glitch.
Built In
Environment is built in to dlux boiler plates, select a preset and modify this line:
Install
Install A-Frame Environment Component by Diego Goberna (GitHub Source)
Setup
Change the environment to any of the predefined ones
Collisions
Physics
At this time, dlux does not use aframe-physics-system by Don McCurdy (GitHub Source) by default.
To create collisions with the ground, floor, and walls, we recommend a nav mesh to restrict player movement.
A nav mesh is an invisible floor that the player is allowed to move on. For example, if you do not want a player to walk through a wall, there should be a gap in the nav mesh so they are not permitted to move there.
This approach has better performance, and allows the use of glTF files with shapes more complex than primitive geometries, meaning your ground can be varied terrain, not just flat. Interaction with static and dynamic objects can be achieved with AABB Collider and SuperHands.
If you need physics, keep reading.
To use the physics system, you must attach body components to the entities you want to participate in the physics system:
static-body for the ground, floor, and walls
dynamic-body for anything that's moveable
kinematic-body for the camera rig (not required)
Each body requires a shape. Ideally, we would use a model for our world, which would have varied terrain in a glTF format as we do with nav-mesh. Set its body type to static and its shape to mesh.
Unfortunately, "shape: mesh" is depreciated, and does not work with the kinematic-body. Therefore, complex shapes are not supported, only simple geometries, like ramps, boxes, and spheres, where shape typically doesn't need to be defined, and the default is auto.
The big drawback to using the physics system is you can't have varied terrain for the floor because shape: mesh is depreciated. If your scene has a flat floor and you want to use physics, here's how:
Add a static-body floor (primitives only)
Add a kinematic-body camera rig
Navmesh
What & Why
As the player moves around the world, we must define where the player may and may not go. The best way to achieve high performance is by defining a navmesh.
A navigation mesh, or navmesh, is an abstract data structure used in artificial intelligence applications to aid agents in pathfinding through complicated spaces. This approach has been known since at least the mid-1980s in robotics, where it has been called a meadow map, and was popularized in video game AI in 2000. Wikipedia
A navmesh is a simplified version of the floor, and can be used for collision detection with teleportation controls, as well as constraining movement controls.
Built into dlux
Navmesh comes built into dlux boilerplates, and should be updated as the scene changes. Once you build your scene, create a navmesh, then reference it in the scene by linking to it in this line of code:
In the easiest case, a nav mesh can just be a simple mesh covering parts of the scene where characters are allowed to travel. Stairs become ramps, and obstacles are holes in the mesh. Don McCurdy
There are many different ways to create the glTF for your navmesh. Here are some of the workflows we have had success with.
Navigation Mesh A-Frame Inspector Plugin
Don McCurdy's plugin for the A-Frame Inspector allows creating of a navigation mesh from an existing A-Frame scene
A-Frame Inspector Plugin Recast
Create your scene
Use this plugin to create and test a navigation mesh
You can make a navigation mesh in A-Frame using a primitive, but only one navmesh is supported in a scene. This works fine for a big flat floor, but being limited to one primitive doesn't work for building varied terrain, which instead requires one of the other methods of generating a glTF to use for the navmesh.
Finally, you need to add a bit of script for nav-pointer. This is already done in dlux.js, and can be added to an existing file, or inline:
<head>
...
<script>
AFRAME.registerComponent('nav-pointer', {
init: function () {
const el = this.el;
// On click, send the NPC to the target location.
el.addEventListener('click', (e) => {
const ctrlEl = el.sceneEl.querySelector('[nav-agent]');
ctrlEl.setAttribute('nav-agent', {
active: true,
destination: e.detail.intersection.point
});
});
// When hovering on the nav mesh, show a green cursor.
el.addEventListener('mouseenter', () => {
el.setAttribute('material', {color: 'green'});
});
el.addEventListener('mouseleave', () => {
el.setAttribute('material', {color: 'crimson'})
});
// Refresh the raycaster after models load.
el.sceneEl.addEventListener('object3dset', () => {
this.el.components.raycaster.refreshObjects();
});
}
});
</script>
</head>
Player Rig
Player Controls
AR Marker
UI Overlay
Blockchain Operations
Second Layer
The dlux side chain is comprised of several nodes running the same token software that determine their state from only signed transactions on the steem blockchain. Together these nodes communicate through steem and perform complex tasks. Forming a distributed trusted third party for open ended transactions, multiparty contracts, and multi step processes. These node will arrive at consensus and maintain sharding information for each node.
DLUX Node Framework
State Nodes maintain state in RAM
Every 100 blocks, a state file is posted to IPFS
Each node then queries the API of each node to see what file was posted and broadcasts agreements so a deterministic state can be calculated using the blockchain as a gossip protocol.
off-chain services now have deterministic consensus that can be rewarded via PoB.
Decentralized Mesh Network
Each node queries every other node to make sure there is consensus to verify the non-reversible block every 100 blocks that issues block rewards, which are determined by the bid rate (cost of running a node) determined by the users running nodes, and the users querying
An average of the top 20 nodes in each category sets the bid rate (price per unity).
The hash is deterministic and already agreed on, the outcome is easy to know, because the if statement is known.
Configuration: env vars:
posting posting key
active active key Can perform escrow transactions for rewards
ACCOUNT steem account ie dlux-io
DOMAIN Public / ie https://token.dlux.io
BIDRATE If elected a runner, used to determine node payouts
STARTING Hash from a recent block. Find one at https://token.dlux.io
API: Read:
/@username -> DLUX balance and Powered Balance
/stats -> Current Info
/state -> State dump, for testing
/runners -> Who is trusted to process blocks
/markets -> DEX Info, in progress(80%)
/dex -> DEX Info, in progress(80%)
Write: CURRENTLY dlux_test_ prefix!!! Custom JSON:
send | to (account to not checked) & amount (integer, no float)
power_up | amount (dlux to power up for voting)
power_down | amount to schedule for power down 1
vote_content | author permlink weight(1-10000)
node_add | domain(https://token.example.com) bidRate(1-1000) marketingRate(1-2000}
node_delete
set_delegation_reward | @dlux-io to set delegation reward rate (0-2000)
expire_post | @dlux-io to expire resteem rewards for specified post permlink
set_resteem_reward | @dlux-io to set resteem reward rate (0-10000)
Operations
Setting bennifactor rewards to @dlux-io >= 10% to make post votable 1
Transfers to @robotolux automatically distributes ICO auction
Delegations to @dlux-io paid daily and tracked automaticly
Votes tallied and paid after ~10 days
Decentralized Exchange
The Hive accounts running DLUX software in consensus are able to facilitate token swaps utilizing the following protocol.
Alice has 10 Hive, and wants to buy 10 DLUX. There are no buyers yet, so Alice checks the network to see which nodes are active(fills out escrow fields in advanced area of form), and selects Charlie as an escrow agent, and David to forward the transaction to a buyer, A collateralized escrow agent as well.
Alice signs an 'escrow_transaction' to Charlie and David. The Hive blockchain will ensure all the security around accepting this transaction. The DLUX network will read the transaction, verify it's acceptable, and let all nodes know that Charlie and David both have enough collateral to hold this trade.
Charlie and David will autonomously sign and broadcast the expected 'escrow_approve' transactions. Hive is in escrow between Charlie and David, each of whom have collateralized 10 DLUX. Bob sees the contract: 10 Hive for 10 DLUX, and buys it, That is sends a 'custom_json' transaction on hive with dlux header information.
The dlux network sees this transaction and the 10 DLUX is sent to Alice, and the 10 Hive is released from escrow to David, (David autonomously signs 'escrow_dispute', and charlie autonomously signs 'escrow_release'). The Dlux network withholds 10 more DLUX from each as the custody changes. Once David recieves the Hive Charlie has his dlux retruned plus a fee. David sends the 10 Hive to Bob and then has his dlux returned plus his fee.
At any time the trade will be upto 150% garanteed by the network. Since any one actor can hold any number of accounts some of the held escrow would be burned(sent to null) to prevent attacks that could withdraw dlux voting power early. On inflow trades like this holding a trade will be more costly as the escrow must be held longer.
While nearly the same chain of custody happens in the reverse direction, the order sits on the dlux side with out the need to collateralize the trade until execution.
Because collateralizing these trades requires liquidity, these trades can not be free. Especially inflow and time based fees are being implemented(the listing fee is 1/2 of the execution fee, and would need to be paid incrementally to keep an order open).
Collateralization is also a finite resource, as such the network itself must regulate acceptable trades and autonomously cancel orders that fall out of acceptable bands to free liquidity at market prices.
No information asymmetry either way, all transactions on the DX are open.
DLUX OpenToken
The first dlux tokens are being sold at auction in VR right now dlux.io/ico
dlux tokens allow us to reward user actions like re-steeming our ads, sharing dlux on other social platforms, and other types of engagement.
Incentivize to participate in the dlux p2p economy
Distribute tokens from the reward pool to token holders, based on Hive rewards
Incentives for any action a webserver can verify
Decentralized exchanges with asset transfer
Issue tokens from our auction pool daily
New tokens added to the reward pool can be earned by token holders for dlux content based on beneficiary rewards.
The first dlux token is built using steem-state
dlux maintains a steem-state node to generate the reward pool
the reward pool pays for the node and incentivizes other nodes
the more nodes, the stronger the network gets
At ~5% APY inflation
Every 100 blocks 1 DLUX token is minted for every 2100.000 DLUX in existence.
The reward pool is used to incentivize others to run steem-state nodes to verify integrity and that we're running our code fairly and correctly, provable through the hash. The 20 fastest verification responses earn rewards.
Decentralized Exchange (DEX)
Non Fungible Tokens (NFTs)
In addition to the dlux Token, we have created a smart contract framework for building Non-fungible Tokens (NFT). They can contain key-pairs for activation, meaning you can ship devices deactivated and require codes for activation, similar to the electric scooter model. Our NFT framework creates a path forward for Internet of Things (IoT) governance.
EXAMPLES
Auctions, Prediction Markets, Equities
IPFS Pinning Service
Content uploaded to dlux automatically receives an IPFS NFT smart contract that looks for IPFS pinning services currently bidding to host content, and chooses the cheapest one to place your content. The contract is funded through the dlux rewards pool.
Free Physical Security
Increase your level safety anytime there's danger by inviting your family and a jury of your peers to watch and listen in. Push a single button to initiate a contract that contacts your next-of-kin (NoK) capable of taking legal action, and your 12 closest friends familiar with your life. Send your location and open a one-way audio call, or activate the camera. Broadcast irrefutable evidence to the people you trust, instantly and automatically.
AR Scavenger Hunt (Augmented Reality Location Based Experience)
Cryptographically run a location based experience with side-chain soft and hard consensus (dlux) on a distributed computing platform (STEEM) inside an augmented reality container (WebXR) on the decentralized storage system (IPFS).
Flow
Attendees are on-boarded to STEEM through dlux
Event NFT is transferred to their dlux Wallet
Attendees physically search the event for AR markers with their mobile using WebXR
Each marker seen by the camera signs a checks a box inside the Event NFT
The Event NFT can be completed, or expire at the end of the event
At completion, the NFT pays out, and the user recieves DLUX tokens, trophy NFT, or anything else
At expiration, the NFT pays out according to the table for the quest progress, and returns the remainder to the event
Account Creation Tokens
Asset Pinning
DLUX Node Network
dlux is the ultimate decentralized computer
Out of the box dlux supports the Hive blockchain, a social media proof-of-brain system utilizing upvotes to reward content creators from a rewards pool.
We offer one-click publishing to the Hive blockchain in a monetize-able vessel that pays crypto currency for upvotes.
Hive functionality is built into both the 2D apps, and VR / AR scenes themselves, so for the first time people can interact with the blockchain from inside another reality.
dApp's will also have the ability to utilize our IPFS infrastructure to host data from user apps. Allowing dApps to be built with no upfront infrastructure cost.
dlux.io Wallet & Sandbox
Smart Tokens
Cryptographic Transactions
Asset Storage, Exchange, Licensing
JSON Smart Contracts
Encrypted Relay
P2P Free Markets
Communications
Side Chains
Custom IPFS
Pinning Service
Public Node
Serve Custom Data
Third Party APIs
Reticulum VR Chat rooms
WebRTC
Turn Server
The dlux token architecture is unique in that it uses web worker nodes listening to every signed Hive Transaction (HTx) via DSTEEM (GitHub Source) to determine state. The can also perform actions on those signed HTx because the nodes have Hive Credentials (HC), which they can use to place the transaction back into the DSTEEM transaction stream.
DLUX nodes form a consensus. And can even collectively hold the keys to their HIVE funding accounts using multi-signature account authorities.
dlux Node listening to HTx
dlux nodes use steem-state, are super easy to run, and can do things like:
Content Management System (CMS) to build databases of private, encrypted information
Internet of Things (IoT) governance such as resource management
Create and sign Smart Contracts, witness transactions, hold and release escrow
dlux nodes power the decentralized exchange, dlux Token, and dlux NFT smart contract framework.
DLUX API
dlux is the ultimate Hive blockchain infrastructure. Not only does it publish any type of dApp you can imagine to the chain, it allows those posts to make posts!
Token API
Read-only, allows you to see token stats
api:port/markets //json markets (has list of api's)
api:port/stats //json stats
api:port/@username //json balances
Writen via customJSON messages.
Post API
The following API allows users of your dApp to request to post new content to dlux:
Triggering the following code from the XR container will prompt the dApp user to make a Hive post
window.parent.postMessage({
'func': 'advPost',
'message': postData
}, "*");
var postData = {
title: title, //required
body: body, //required
permlink: permLink, //optional: will autogenerate if not supplied
parentAuthor: '', //optional: make comments
parentPermlink: '', //optional: make comments | change categories
beneficiaries: {disregardfiat:1000, markegiles:1000}, //optional: incentivize yourself. (Max 3000)
customJSON: JSON.stringify({
tags: otherTags, // you are responsible for tags
subApp: 'SuperCraftLoader/v0.1', //name the application that will be posted
xr: false, //if you'd like the XR interface or
vrHash: 'QmbDb84sAVJYYw7qHFwiX88QRswWu8d7sf4Wr5sYWHSzJZ', //an ar or vr hash must be specified
appSpecificData: userVar //anything else needed to make the dApp work
}),
}
On the user's side a few items will be added to this data, such as the dlux main app and dlux beneficiary information as well as an "attorney" so users will be able to see which users dApp helped them make a this post.
Integrated Wallet
Our wallet handles HIVE assets, as well as DLUX assets.
Unified Asset View
See all your assets in one place:
Cryptocurrency Tokens
Smart Contract Non-Fungible Tokens
Authenticated users can perform:
Asset Transfers
Escrow Transactions
Voting
Delegation
Send API
code here
Balance Inquiry API
code here
IPFS Gateway
IPFS Upload
Upload assets to IPFS from dlux.
IPFS Pinning
dlux pins content that is uploaded to IPFS and .
Others are encouraged to build competing pinning services and bid in Open Markets.
IPFS API
js-ipfs-api (GitHub Source)
const ipfs = window.IpfsApi({ host: 'ipfs.infura.io', port: '5001', protocol: 'https'}) // Connect to IPFS
const buf = buffer.Buffer(reader.result) // Convert data into buffer
ipfs.files.add(buf, (err, result) => { // Upload buffer to IPFS
if(err) {
console.error(err)
return
}
let url = `https://dlux.io/ipfs/${result[0].hash}`
console.log(`Url --> ${url}`)
IPFS Oracles are hosting nodes that pin assets to storage.
Others are encouraged to provide services and bid the cost down, just like on AWS (Amazon Web Services).
Here is a data structure for our IPFS pinning service:
All participating witness nodes bid, and the lowest 20 bids are averaged to determine the price. Reward tokens are paid out equally. The program verifies your service is online, and tokens are distributed from the rewards pool per kb stored.
Call dlux-token for stats
dlux-token returns the preferred IPFS nodes you can upload to
Upload event happens, program records kbs data transfer
kb/reward amount paid out from rewards pool
Hive Integrations
The Hive blockchain provides our foundation through authentication.
It has two forms of currency tokens, HIVE and Hive Backed Dollars (HBD):
HBD is a peg to USD
HIVE can be powered up, into Hive Power, which gives the Hive Account more stake on the Hive Network, this can also be delegated risk free.
Running a Hivemind witness node would allow dlux to run plugins that monitor HIVE data, which would allow for things like search, and notifications. Currently this is part of our roadmap.
