Digix Core Dev Update News



  • # Digix Core Dev Update Nov-2016




    Chris Hitchcott (Core Dev)

    This week I continued on unit testing whilst sharpening Digix’s testing toolkit. There were a series of upgrades to existing projects we released and the DGX 2.0 test suite.

    I’ll keep it simple this week by roughly outlining my completed tasks:

    Contest
     — Redesigned API: more powerful and readable
     — `deploy`, `call`, `tx`, `watch` methods
     — `it` and `before` blocks for arbitrary async scripting between steps
     — Fix edge case with TestRPC event (related issue)
     — Updated tests

    Sigmate
     — Simplify initialization API
     — Removing naming system; just use address array
     — Add option for keystore password
     — Updated tests

    Solidity Boilerplate
     — Integrate contest / doxity / sigmate
     —EIP20 (con)tests inspired by Consensys’

    DGX 2.0
     — Update contest api
     — Additional tests

    Follow us on Github



  • Digix-Progress Update 17/11/16


    Seattle Digix Presentation


    Anthony Eufemio and Chris Hitchcott presented on smart contract architecture and the suite of dev tools created at Digix respectively last week. The video is currently being edited by the meet up organizers in Seattle, and will be posted as soon as it is ready.

    MAS Fintech Annual Awards, 14 to 18 Nov 2016


    3 Blockchain companies were in the running amongst 40 Finalists in the Annual Fintech Awards 2016 in Singapore. Namely, they were Attores, KeyChain, Digix. We hoped that at least one blockchain company would be recognized for their work but none of us clinched an award this time round.


    Fintech Awards Night

    Digix Mentioned at the awards

    2 Meetups held this week

    2 meetups were ran this week, co organized by Digix. Gavin from Ethcore provided an introduction to Parity to the Singapore community this Tuesday. The video of his presentation is linked here. Special thanks to Attores for providing the recording.





    Gavin on Parity at the Ethereum Singapore Meetup, video:





    We managed to squeeze a quick dinner with the Ethcore team to thank them for their continual work and efforts.



    Dev Work — Migration Wallet
    We have begun preparing a migration wallet for DGX 1.0 users. This will allow users to use their current DGX 1.0 wallets for DGX 2.0.
    More information will be published in a separate blogpost. Thank you.


















































































































  • Digix Core Dev Update 24/ 11 / 16

    Chris Hitchcott (Digix Core Dev)

    Greetings! Chris here to once again update you with this week’s development activities. We’ve been busy with continued work on the toolchain and have a few new releases that we’re using in our stack. In order of descending ‘coolness’, here they are:

    Doxity 0.3.0

    https://digixglobal.github.io/DigixMath/docs/DigixMath/For me the most exciting thing to announce is the update to Doxity that now integrates more closely with truffle. So closely, in fact, that if a contract has been deployed with truffle, the generated documentation will contain an interactive GUI so anyone visiting your documentation site can play around with your live deployed contracts — (don’t worry, no transactions, just `call`s).In case you didn’t know Doxity is our recently released tool that automatically generates static HTML webpages from natspec-commented solidity files. Previously this was purely as a nice way of viewing the comments on a published website.But now we’ve gone ahead and made it much cooler by having it interact with real, deployed, on-chain smart contracts. Check out the demo site — which has contracts deployed to morden that you can interact with by filling in the input boxes. Thanks to infura for the hosted node.


    Truffle NPM Libraries

    Example: https://github.com/DigixGlobal/DigixMathDuring devcon I learned about truffle’s 3.0 beta release which includes support for npm-packaged solidity files. Basically, this allows us to leverage node’s package manager with solidity contracts, whilst keeping track of deployment addresses for different network.We’ve now implemented this feature and will be using it for the release for the Digix core contracts. The benefit here is that both Digix and non-Digix developers can extremely easily import our contracts (and even deployed contracts) into their project without having to copy the source code.We hope using this approach will encourage synergies and code-sharing within the solidity ecosystem, and be a foundation for future development patterns similar to this. Peronally I believe that node’s success is closely tied with the excellent NPM, which has become a staple tool for any javascript dev. In time, hopefully it’ll be the same for any Solidity dev, and we’ll have tonnes of easily-shared pre-deployed Solidity contracts that devs can make use from.


    Sigmate 0.2.0

    https://github.com/DigixGlobal/sigmateSigmate is a tool that was being used for keystore management in our core project, signing transactions within the test environment rather than the node. We’ve explained why this is cool in a previous post.This week, along with the aforementioned truffle integration, sigmate has been updated to better integrate with truffle — hooking in at the config file level rather than the test/deploy/execution environment. This makes for a more vanilla-truffle-like experience when running tests and relegates the use of Sigmate to a single line of code in truffle.js.Sigmate now also uses the new wallet keystore format (with a custom ProviderEngine plugin to handle multiple accounts), and we’ve introduced a CLI tool for generating new keystores with minimal effort.


    Migration Tool

    https://digixglobal.github.io/wallet-migration/migrate/Finally, we’ve created a little tool to help with the release of 2.0 — a wallet migration tool that will convert old-style Digix lightwallet keystore into the fancy new `V3` style, which is compatible with Geth and MyEtherWallet.







  • Digix Seattle Meetup Presentation Videos — Nov 2016

    Solidity Contract patterns and security — presentation by Anthony Eufemio (Digix CTO)



    Javascript testing framework for Solidity smart contracts — presentation by Chris Hitchcott (Digix Core Dev)


    Special Thanks: Kenny Rowe from MakerDAO for editing the videos




  • Announcing Spectrum — Full Gamut Lightsuite for Ethereum Blockchains


    Digix is providing a new UX solution for interacting with Ethereum with the purpose of increasing future adoption of DGX and the wider ecosystem.


    Lightwhat?

    What is a Lightsuite? It’s a word invented to describe that what wasn’t fully encapsulated by the term Lightwallet.Basically, a Lightwallet in the case of Ethereum is a piece of software that provides an interface for users to interact with a blockchain by creating accounts, connecting to a node, reading chain data, signing and broadcasting transactions.At some point, though, a Lightwallet gets too many features to be properly considered a ‘wallet’ anymore. The Mist browser, for instance, is more of a multi-tool than a wallet. It’s got an address bar and everything, so we call that a ‘browser’. But what if it hasn’t got an address bar?Well, similar to a Mist, a Lightsuite is a full spectrum of tools for Ethereum — and just like a Lightwallet, they’re available in the browser; it’s a user interface for connecting to Ethereum by via a hosted (or local) node.

    Let there be Light

    Over the last couple of weeks I’ve been working on the groundwork for a Lightsuite called Spectrum, which we at Digix will be using to help the development of the Ethereum ecosystem and for use in future Digix and third party projects.The main goal of the project is to create a tool that provides the best possible user experience for the full spectrum of users; investors, developers and casual. One critical requirement is be a ‘zero-install’ entry point (i.e. web-based) for zero-friction welcome to Ethereum.For developers (and in particular us at Digix), it also means more rapid development of dapps — no accounts or web3 state management to rewrite, so new DigixDAO experiences can be rolled out faster than ever, and will be one-click away from existing Spectrum users.There are a number of tools existing that tick some of those boxes, but there are currently no offerings that cover this full spectrum of ‘Best Possible UX’ options.Please note, screenshots in this announcement are early alpha and may not fully reflect the completed project.

    Feature Overview

    Spectrum achieves its UX goal through a combination of technologies that marry the accessibility of MyEtherWallet, the portability of Jaxx and the dapp store platform vision of Mist/Parity.



    Might not be 100% accurate when you read this; please let me know when it becomes outdated!)

    Adoption First

    The ultimate goal of Spectrum is to provide a low-barrier easy to use experience whilst still providing a powerful set of tools. There are a few key features in terms of both accessibility and UX design that together ensure that a wider number of users can intuitively make use of Ethereum.Works everywhere instantly with no installs By connecting to Ethereum using third party nodes and signing transactions on the client, an acceptable balance of security and convenience is achieved without requiring a central trusted service. Designed to work fully featured in any modern browser and device, using Spectrum is as simple as visiting a website, and requires no waiting for the blockchain to re-sync.Travel with your application state Depending on your security/convenience tolerance, Spectrum’s encrypted app-state backup system allows you to sync your accounts, transactions and other data with a number of storage adapters with ease, and share individual app sessions with multiple devices using JSON File, Google Drive, Dropbox, IPFS and eventually, Swarm.Responsive design The Semantic UI responsive grid is used extensively to provide an optimized user experience on mobile, desktop and tablet.1st class support for offline transaction signing Generate data with every transaction for offline signing, allowing for a seamless cold-storage experience.

    Sessions and Keystores

    Session backups include accounts configuration and Ethereum private keys (in encrypted geth-compatible format), as well as application state and transaction history.




    It lets you easily divide your portfolio up into different security groups depending on use case, and keeps the (already encrypted) wallets along with the account-specific application data in the same place encrypted with AES256 + optional custom entropy.In app storage and runtime state, keystores are always stored as the standard, serialized, encrypted v3 objects. A secret key that is not saved in persistent state is required to be entered to decrypt and sign the transaction.

    Various storage adapters are available for backup/restoring of sessions, as well as standard exporting for keystores.

    Keystore Exports compatible with Spectrum, Geth, MyEtherWallet, etc.

    • JSON
    • Mnemonic
    • Private Key

    Session Exports compatible with Spectrum, optionally encrypted

    • LocalStorage
    • JSON
    • Cloud Backup (google/dropbox)
    • IPFS
    • Swarm



    Multi-Nodes

    Users can configure multiple networks and providers they connect to in-app, giving complete flexibility during testing, production and private deployments. Either connect to a local geth/parity service or connect to a remote node — be it private, premium, or public (although defaults aren’t confirmed yet).



    We’re hoping to work with some existing node providers (such as Infura, Azure, etc) to provide a service for Spectrum users by default on Ethereum Mainnet and Testnet.

    Plugins & Middleware

    Spectrum’s dynamic provider creation and redux architecture allows for powerful, unobtrusive user experiences; particularly for signing transactions. Developers can register custom signing components that provide custom UI for different types of signing — be it Hardware wallets, 2FA contracts, or other third party services.

    Dapplets

    Spectrum comes complete with a selection of official and community ‘dapplets’ — fully fledged apps that run within React components in the Spectrum environment and use its accounts system to sign transactions (whilst seamlessly hooking into any transaction signing plugins).Spectrum provides dapplet developers with an intuitive web3-style syntax for hooking into the accounts system and managing web3 state, with a custom redux environment injected for each dapplet. Dapplet state can be saved persistently between sessions so authors can deliver a superior long-term experience.Dapplets are lazy-loaded on-demand to reduce the initial bundle size and give users an optimal experience for their use requirements.

    Digix Dapplets One of the main reasons for the creation of spectrum is to facilitate future official Digix projects, including UI for upcoming contracts and services:

    • DGD Governance / Voting
    • DGX Reward Claims
    • Aegis Vault
    • TBA Future Digix Services

    Dapplet Registry Initially an official list of dapplets published by Digix will be added to a single Spectrum dapplet/plugin registry, including standard types:

    • Tokens (EIP20 and misc. types; pre-populated / custom)
    • MultiSig
    • 2FA Signing
    • Scriptable actions (e.g. tumbling)
    • Custom token signer (e.g. nano ledger, trezor, etc.)
    • Generic contract/ABI interaction
    • With a bit of luck, browser-solidity

    Custom Registries In future releases the registry contract will be updated to enable community dapplets with content verified by author address and content hash, and eventually custom registries (pending a security review).

    Technology

    There has been a lot of advancements in the world of web application development in the last year or so, and having migrated away from Meteor/Blaze earlier this year, I became familiar with a delightful toolset that plays particular nicely with client-side apps. Having used it for around a year, I was confident that it was the best pick for a complex modern application like Spectrum.Ticking all of the boxes can only be achieved with a specific tech stack, which will be open source and offer a free commercial use license.

    ES6 HTML5 Web App

    • Offline support
    • Optional encrypted LocalStorage sessions
    • Modern, composable, extendable, tree-shakeable, importable architecture
    • Modular separation of core/UI logic
    • Component Lazy Loading

    React Components

    • Reusable UI Components (e.g. Account Selector)
    • Wide Developer Adoption
    • Excellent Developer Toolkit
    • Mature Package Community

    Webpack Bundler

    • Aggressive bundle optimisation & partitioning
    • Seamlessly deploy to multiple environments
    • Ubiquitous client-only deployments (Github / IPFS / Serverless)

    ProviderEngine

    • Dynamic provider and accounts injection per-container
    • Transaction signing UI plugins/middleware
    • Custom Node Config: Ethereum, Ropsten, Private Chains

    Web3-Redux

    One major component is web3-redux, a library I’ve been working on as part of the spectrum project. I’m particularly happy with it’s integration with the redux architecture by using a familiar web3 api. It can be used as such:



    Web3-redux does a bunch of wiring up in the background to handle the actions and reducers for web3 requests, and ties them all behind the same-style web3 API for use in redux apps.

    • Simplified web3 integration with reactive pseudo-syncronous style
    • Injected redux state/methods with traditional web3 api
    • Promisified contracts/transactions
    • Intelligent fetching/caching middleware
    • Other potential middleware plugins options in the future

    Stay tuned for more on web3-redux as development progresses.

    Semantic UI

    SUI is our favourite CSS framework, and it’s recently come with a new react library which makes it even more delightful to work with, and along with some custom components, it’ll be the underlying fabric for the Spectrum GTK.This might deserve it’s own blog post, but i’ll summarise

    :

    • Beautifully crafted components
    • Fairly common usage in the wild
    • Standardised UI for intuitive usage
    • Also standard between dapplets (think myspace -> facebook)
    • Declarative API for developers
    • Lightning fast React library; no jQuery
    • Theme Manager w/ Community Themes

    Roadmap

    Here’s a rough, best-case-scenario estimate of progress. We’ll be open sourcing after alpha release, so you can follow development on github.

    Alpha (Next Week)

    • LocalStorage Sessions
    • JSON, Mnemonic, Private Key Import/Export
    • Quick ETH Transfer
    • Token Transfer

    Beta (Jan/Feb 2017)

    • Address Book
    • Cloud Backup
    • IPFS Backup
    • Hard-coded dapplet regsitry
    • Theme Manager
    • Transaction signing plugins
    • Cold storage transactions

    Stable 1.0 (Q1 2017 + beyond)

    • Security Review
    • End-to-end test coverage

    Fandango

    • i18n (Chinese esp.)
    • QR code scanner for mobile
    • Hardware wallet support

    Majorelle

    • Community dapplet registry contract
    • Digix governance dapplet
    • 3rd party services dapplets
    • Dapplet develop toolkit

    Harlequin

    • 2FA signing
    • Swarm Backup?
    • Raiden network?

    Aureolin

    • Chrome extension & Electron/Cordova apps

    Carmine

    • TBA Premium Services

    Trivia

    Why Sprectrum? Apart from the reference to all-encompassing feature set, it was originally an ode to ‘Electrum’ and is a play on Lightwallet. Also it sounds badass and opens up the opportunity for a slick Ethereum Icon / ‘Dark Side of the Moon’ mashup logo.

    Thank You

    One last thing I wanted to do was a give a shoutout to all the Digix fans and DGD holders who have continued to show their support and patience whilst we build these tools in the right way. For the future. I hope this contributes to the Metropolis vision and as Spectrum evolves.I welcome all your feedback!Catch you next week with an alpha demo.To Note:
    Development on spectrum will not affect progress on DGX 2.0, in fact, it will have a positive effect on DGX 2.0 and DigixDAO as all our DAO governance UI will be on Spectrum.




  • # Spectrum Pre-Alpha Demo — New Year Eve Special ## Happy holidays everyone! ### This week I’ve been completing the additional functionality for the alpha demo of Spectrum promised last week. We’re pleased to announce a demo of spectrum is available — both as a video and live demo website. ### For a visual step-by-step run through of the current functionality, please check out this video below. ### https://youtu.be/8Jo-fvcTCOM ### Please be aware that the current implementation is most certainly in the “MVP Technical Demo” state and does in no way reflect the final UX or feature set — it does showcase the bare bones core functionality of Spectrum, including multiple accounts, multiple networks, persistent sessions, transaction signing, and a rudimentary but functional token transfer Dapplet. There may be yet-to-be-descovered bugs and the ‘optimised network communication’ middleware hasn’t been implemented yet. We’re also aware of an issue with localStorage when using multiple tabs, which will be addressed before the next release. ### Or, you can have a play yourself at the following URL (http://spectrum-alpha.digixdev.com/). As always, with pre-release software, assume ZERO security at the moment — there are no guarantees about not losing funds sent to Spectrum accounts! Additionally, the Ethereum nodes are currently set by default to Infura, and there are no guarantees they will remain online (we are currently discussing long term support); you can always configure Spectrum to use an alternative. ### Since last week’s announcement, a couple of additional opportunities have identified that we think will add to the success of the project. ### Even better mobile support ![0_1483177397949_daosp.png](https://i.imgur.com/OVTV4JD.png) Spectrum Mobile Support ### A relatively little-known feature of both iOS Safari and Android Chrome is the ability to add web-apps to the home screen and have them act like native applications and have them run even without an internet connection. Spectrum will implement these features to give an even better user experience for mobile users who are used to using apps rather than traditional websites. We’re also adding QR-code links and scanning to our feature list to enable super-easy payments and generic dapplet transaction signing. ## Community Organizing ### After announcing Spectrum last week a number of parties were interested in helping contribute in various ways including dapplet porting and contributing to the core codebase. As such, the coming sprint will be focused on creating a community-orientated repository including project management tools, dapplet creation tutorials, documentation and of course a bit of refactoring to make the source code ready for public use. ### We’ve decided to set this up before the 1.0 release to encourage early developer adoption. If you are interested in contributing to Spectrum, please stand by for future announcement, and if you have previously reached out, I’ll be in touch with more details soon. ## Webpack is freaking awesome ### One thing that wasn’t noticed until I got to the bundling stage of deploying the demo was how fantastic a choice Webpack was as the build pipeline for this project. ### Thanks to Webpack’s aggressive merging and ES6 tree-shaking functionality, we present to you spectrum in a minuscule 606KB gzipped bundle (which, considering it includes all the crypto libraries is impressive). ![0_1483177723067_1 EYRnIIWgrxio0iNHP69nlw.png](https://i.imgur.com/9UEnCtt.png) 606KB bundle ### Beyond this ‘default’ config, there are even more opportunities to fine-tune Webpack to achieve insanely small (possible <100KB initial payload, with feature-specific lazy-loading) load times for the best possible UX. I am now officially a Webpack zealot; if you are ever considering building a web application, give it a try! ## 2017: The Year of Metropolis ### With an increasing number of higher-level applications coming out in 2017 we’re, really excited to be contributing to the Metropolis vision of Ethereum in the coming year. I wish all our readers a happy new years celebration and prosperous 2017. We at Digix are certainly looking forward to it!


  • Core Dev Update : 7 Jan 2017

    We have several requests to emulate Augur’s developmental updates which shows a concise snapshot of their current progress.

    We think that Augur came up with a good idea to help supporters keep abreast of their developments, hence Digix will follow suit with our own version this week onwards. Our developer commits will have more descriptive comments moving forward as they had been for internal / private references. It also allows Digix developers to provide updates on the fly without needing to spend additional man hours consolidating a new set of report every week.

    Below is a short snippet on what has been worked on for the 1st week of 2017. (Report link can also be found here)

    Project github.com:DigixGlobal/core2-contracts

    • b28a1cb — implement updated truffle imports api
    • 07cc708 — stateless import
    • 03105fc — imports script for console
    • 5c5eb1d — update testnet network & used fixed truffle version
    • ca9c860 — WIP console issue
    • 56c0924 — sort out truffle imports
    • 4ff273e — setProvider issue WIP
    • 0c82128 — WIP — morden node error
    • 307e909 — update package name to use private npm

    Project github.com:DigixGlobal/sigmate

    • 1a204b8 — update deps (esp. provider engine), minor refactor

    Project github.com:DigixGlobal/spectrum-core

    • 9bd4bdb — add exportKeystore
    • 402a993 — refactor imports, import private keys
    • cc192f1 — update network config
    • 618d65a — refactor, contractConnect
    • 3a3c6a6 — dynamic providers
    • 89ada28 — redux hooked provider WIP
    • 3eac1af — [wip] use multiple providers in bindConnect
    • d3f5b07 — import/export json working
    • 1f90bbb — update default state
    • 2d5eca9 — add setState
    • c3f2d22 — completed localStorage backup/restore implementation

    Project github.com:DigixGlobal/spectrum-ui

    • eaf7be5 — minor UI fixes
    • 3576b01 — fix restore json file on mobile
    • d70c3f3 — EIP20 Tokens MVP
    • d811125 — network config, dynamic networks
    • 5497015 — working tx signing with quick-transfer
    • 8b7383c — fix up tokenTrasnfer
    • 375c80c — working multi-chain accounts
    • a7810ac — backup/restore ls/json
    • ad20397 — better guest mode handling
    • 535df95 — big backup/restore refactor & full LS implementation,

    Project github.com:DigixGlobal/cacp-contracts

    • 502c7d0 — change morden provider
    • 7cca88d — bump version
    • fe8861c — update package name
    • 175cd47 — change package name
    • eb748a8 — Merge branch ‘master’ of github.com:DigixGlobal/cacp-contracts
    • a0a7495 — add some documentation
    • d0dee1b — Set theme jekyll-theme-cayman
    • 43f6be3 — add some documentation
    • 17ea36f — tests WIP

    Project github.com:DigixGlobal/solidity-core-libraries

    • 61269f8 — bump version
    • ba637ad — update testnet provider
    • 2742127 — update documentation
    • 02be94b — ignore error log


  • Digix Dev Update — 20 Jan 2017

    Project github.com:DigixGlobal/spectrum-core

    • d2f9089 — [feature] crosstab syncing
    • 3feb2e2 — [maint] show build time for cache debugging
    • d0c6f2e — [bugfix] fix json export
    • c3f85a3 — [bugfix] working offline (with no internet) on mobile
    • 914e13e — [feature] basic implementaiton of redux-presist (todo UI)
    • da56283 — [bugfix] manifest loading
    • 2fb879c — [feature] use external https testRPC provider
    • 8bbb833 — [maint] update ezmodal, use yarn
    • c877f6c — [maint] add react-optimize
    • cc69783 — [feature] implement offline-plugin
    • b5fc927 — [feature] add padding to encrypted json
    • 2ca9906 — [feature] backwards-compatible salting for decryption
    • 9efa6f4 — [bugfix] fix decryptObj import
    • 79d6010 — [feature] merge tokens and base tokens into accounts
    • ae765e2 — [maint] refactor merged imports using babel-root-import
    • 53845e1 — [feature] don’t show tokens if network not connected
    • 71a428f — [feature] connection status indicator
    • 553cdef — [maint] minor webpack config; better debugging
    • 5ec777e — [feature] implement network-specific connection status; dispatch WEB3_INIT

    Project github.com:DigixGlobal/Spectrum

    • d2f9089 — [feature] crosstab syncing
    • 3feb2e2 — [maint] show build time for cache debugging
    • d0c6f2e — [bugfix] fix json export
    • c3f85a3 — [bugfix] working offline (with no internet) on mobile
    • 914e13e — [feature] basic implementaiton of redux-presist (todo UI)
    • da56283 — [bugfix] manifest loading
    • 2fb879c — [feature] use external https testRPC provider
    • 8bbb833 — [maint] update ezmodal, use yarn
    • c877f6c — [maint] add react-optimize
    • cc69783 — [feature] implement offline-plugin
    • b5fc927 — [feature] add padding to encrypted json
    • 2ca9906 — [feature] backwards-compatible salting for decryption
    • 9efa6f4 — [bugfix] fix decryptObj import
    • 79d6010 — [feature] merge tokens and base tokens into accounts
    • ae765e2 — [maint] refactor merged imports using babel-root-import
    • 53845e1 — [feature] don’t show tokens if network not connected
    • 71a428f — [feature] connection status indicator
    • 553cdef — [maint] minor webpack config; better debugging
    • 5ec777e — [feature] implement network-specific connection status; dispatch WEB3_INIT

    Project github.com:DigixGlobal/web3-redux

    • 6fc69cf — [maint] update scoping for redux-persist reducers
    • cadde08 — [maint] bump version
    • c47cbcc — [bugfix] bulletproof contract caching
    • 3af7bc9 — [ferature] add WEB3_INIT action & network status
    • 6a1a2ee — [maint] remove web3 dep

    Project github.com:DigixGlobal/wallet-migration

    • aed338b — update github-pages version @ https://digixglobal.github.io/wallet-migration/
    • 8a755b0 — build
    • 7963065 — Merge commit ‘7626acce38f503789e8393416b7ea5188fe2f297’
    • 980af34 — [feature] enable mnemonic import; fixes #1
    • 3edef2b — [wip] import mnemonic (TBC correct HD path) #1




  • Core Dev Update 31/1/2017

    We had some feedback this week that our recent weekly dev updates have been too purely technical. Whilst fellow developers can piece together what’s happening from commit messages, they don’t really help our non-dev followers, so we’re now going to include a short summary of each weeks’ development sprints in (as best we can) jargon-free understandable english. Both Anthony (Digix CTO and Smart Contracts lead) and Chris (Digix frontend/JS core dev) will be providing individual assessments of what they’ve been up to on a weekly basis going forward.

    Anthony Eufemio

    Solidity Work

    We have been doing some major refactoring of the DigixCore 2.0 contracts.

    Code organization:

    - Define data storage into its own separate reusable library.  — Put data related configurations into data storage libraries.  — Refactored contracts to use TokenBank Deployer

    TokenBank:

    - TokenBank is an ERC-20 enabled multisig contract and contract factory that is used throughout DigixCore 2.0 (i.e. token locking, token swap, demurrage pre-payments, storage fee payment, recasting, DGD rewards, DGD voting)  — Refactored TokenBank to use CACP 2.0  — Created TokenBank Deployer contract which can be called by any user or contract to deploy a new custom instance of TokenBank

    IT/DevOps Work

    - DDoS mitigation for our publicly accessible network  — Patched Server OS and updated custom ports packages  — Updated to Solidity 0.4.8  — Updating Digix solidity boilerplate to use latest Digix tools.

    Chris Hitchcott This week mostly involved refactoring — the process of streamlining existing code — as part of the integration of ‘redux-persist’. Basically, before now I had manually written a backup/restore system for Spectrum, but decided to switch over to redux-persist due to it being open source (and maintained by not just me), standardisation, and it’s powerful plugin-system. The plugin-system was the real deal-breaker, as it would allow for transparent integration of a bunch of already-existing storage adapters that backup and ‘rehydrate’ the data.

    The refactoring was required because I had previously intended to use Immutable.js for the entire datastore — both Spectrum itself (accounts / dapplets) and web3-redux (the way that data is saved for ethereum-related calls). However, after some research I concluded that whilst Immutable.js was excellent for large teams that wanted to ensure immutability in redux stores, and it allows for extremely efficient manipulation of deeply-nested data structures, it wasn’t the best choice for Spectrum. That’s because actually squeezing out the performance benefits of immutable.js requires an bit of nuance and an IMO cumbersome API (https://medium.com/@AlexFaunt/immutablejs-worth-the-price-66391b8742d4#.ec0i87fld), that could turn off potential dapplet developers. I wanted to make DX (developer experience) a “first class citizen” in the world of Spectrum.

    Luckily, there were alternatives for modifying deeply-nested data structures (such as future account types that we haven’t even thought about yet, like, I dunno, multi-recursive HD wallets like Ledger Nano) whilst maintaining immutability. The best solution I found was https://github.com/kolodny/immutability-helper (released after the start of Spectrum’s development), which I feel will provide the best DX. Standardising the data manipulation library, whilst still providing a familiar, plain-JS API for superior DX was the major problem I solved this week, and I’ve been refactoring the store (and will be doing so with web3-redux) to take these new design decision into account.

    This is all in preparation for next week, when I’m probably going to be forking the redux-persist encryption plugin enable for UI hooks, as well as building entirely new plugins for IPFS and other stores — using service workers to ensure the restore happen even if the user closes a tab (or kills the app on their phone).

    One more thing that I didn’t explain last week, here’s a demo of crosstab-sync — a redux plugin that elegantly solves the problem syncing data between multiple browser tabs — no server required. Here it is in action with Spectrum:

    Weekly Commit Report

    # Project github.com:DigixGlobal/spectrum-core (Chris) - 35fe521 — [maint] remove old restoreBakcup method (now hanlded by redux-persist) - 25b0121 — [maint] remove potentially buggy rerender check on Acocunt - d6da238 — [maint] better UI for updated networks config panel - 60b7936 — [bugfix] `status` existentiality check to prevevent uncaught error on initial load - fc376a1 — [maint] implement updated web3-redux `NETWORK_STATUS` - 070d75a — [maint] refactor networks store with more sensible data structure - f2f2909 — [maint] [wip] purge references to providers store - bfb701e — [maint] remove duplicated assets - 7e5fe97 — [maint] [wip] refactor accounts store (do not use simplecrud) - 849f4c6 — [maint] re-implement HMR for webpack 2 - 80a2825 — [maint] eslint ignore `new-cap`

    # Project github.com:DigixGlobal/web3-redux (Chris) - 3c291e5 — [bugfix] more accurately update network status when switching providers - d6576ce — [maint] use `key` instead of `id` for network identifier - 6c4aa2f — [temp bugfix] reverse toJS commit; pending purejs rewrite - 7860621 — [feature] return non-connected functions for in-app connecting (fixes HMR state loss) - 700d7e7 — [perf] remove redundant `toJS` - 1005ab9 — [feature] pass provided props to children - 9f5d845 — [bugfix] serialize null values

    # Project github.com:DigixGlobal/core2-storage-library-contracts (Anthony) - 2708973 — [maint] fix tests - 976dc21 — [feature] Digix User storage type



  • Digix Core Dev Update - Feb 8 2017

    I started this week continuing with the refactoring I discussed last week; converting Spectrum’s redux datastore into a more manageable, efficient and developer-friendly format. It’s very nearly done; finalizing how the web3-redux action-creators api will be efficiently generated, but that requires a fair amount of thought and experimentation to get right (whilst balancing with the idea of not over-optimizing before needed).

    But then, midweek, to my surprise, Tim Coulter (and team) released the wonderful Truffle ~~4.0~~ 3.0. Amazing! And, by god, it was fairly different (and superior) to what I had expected having followed along with the 3.0-beta releases. What it meant what that we now have (for the first time) proper modularity of smart contracts leveraging NPM (and finally I didn’t have to re-publish every contract dependancy each time `ether-pudding` updated or needs to be patched).

    This week I studied the new Truffle and migrated the existing solidity codebase. With the majority of contract migrated (pending some minor learning opportunities to do with imported contracts), and the creation of `@digix/truffle-lightwallet-provider` (RIP sigmate), I’ve gained a fair understanding of how the new version Truffle works, and my impression so far is that Tim has done an excellent job eviscerating the codebase into decoupled units. Let it be said: from my perspective, new Truffle is damn good, and I expect it to be relatively stable (or at least there won’t be a huge overhaul) for some time to come.

    On a side note, for now I’m going to be sticking with NPM for contract package management for a little while. Whilst EPM will definitely be a big deal for production package deployments, right now NPM is a development comfort blanket that we’re not quite willing to let go of just yet. Private repos, `npm link`, offline development (via yarn), plus just not having to deal with the extra complexity of an on-chain registry is something that (for development), cannot be beaten by NPM.

    We’re now very happy to be on a brand spanking stable release of Truffle, and I’m extremely excited about the future eco-system that this new contract modularity will enable.

    Weekly Commit Report

    # Project github.com:DigixGlobal/sigmate - 9b9d4ce — [maint] update readme with `expose` - ea278a5 — [feature] don’t show seed on creation, add `sigmate expose` command - 51c9e73 — [bugfix] create correct number of accounts - e7e4d5f — [feature] [3.0] uses `eth-lightwallet` HD keystore, remove truffle-specific code

    # Project github.com:DigixGlobal/Spectrum - 35fe521 — [maint] remove old restoreBakcup method (now hanlded by redux-persist) - 25b0121 — [maint] remove potentially buggy rerender check on Acocunt - d6da238 — [maint] better UI for updated networks config panel - 60b7936 — [bugfix] `status` existentiality check to prevevent uncaught error on initial load

    # Project github.com:DigixGlobal/solidity-core-libraries - 9bf2b97 — [maint] use latest lightwallet-provder, add `prefund` in truffle.js - 6fa8521 — [maint] fix gitignore - 9223909 — [maint] remove another doxity hangover - 7ba84cd — [maint] v0.0.8 - 9f228aa — [maint] use `@digix/truffle-lightwallet-provider`, deploy using ropsten! <U+1F60E> - b473622 — [maint] remove doxity hangover - 9c28aa6 — Merge commit ‘f9bb06575db9112413e51a025da6298d699d27ab’ - 637123c — [maint] use truffle-lightwallet-provider - f9bb065 — [maint] bump version - ce25cc6 — Merge branch ‘master’ of github.com:DigixGlobal/solidity-core-libraries - 334701f — [feature] Add TX fee calculation - 630a533 — [maint] add watch-test script - 8a05390 — [maint] update readme - fd1cf60 — [maint] migrate test environment to truffle 3.0 [todo ropsten] - ef5ea7b — [maint] recompile MathUtils - 1c536a6 — [maint] Bump npm version - 1333f68 — [feature] Move demurrage info function into MathUtils - 5f596cc — [maint] bump npm package version - 06f8db3 — [maint] use underscore for function and variables - a9c129d — [maint] update to match latest boilerplate

    # Project github.com:DigixGlobal/core2-storage-library-contracts - 1a54f88 — [maint] fix MathUtils import & deploy to ropsten - 56e925d — [maint] migrate to truffle 3.0 [wip; figure out MathUtils] - 8c5d287 — [maint] Bump solidity-core-libraries to v0.0.5 - 1b79be0 — [maint] bump solidity-core-library dependency version - 2708973 — [maint] fix tests - 976dc21 — [feature] Digix User storage type



  • Digix Core Dev Update — 14 Feb 2017

    Author,

    Anthony Eufemio (Digix CTO)

    Development work ongoing, report will be detailed in a separate blog post tomorrow.

    Chris Hitchcott (Digix Core Dev) This week we completed the migration to Truffle 3.0 for all Digix solidity libraries and performed upgrades to the tooling to ensure a streamlined dev environment.

    I created a library that injects some useful helpers into the truffle `console` environment, modified `truffle-contract` to work with infura for deployments (previously they would fail due to the use of filters, so I created a custom deployment script that avoids using them), and `@digix/truffle-lightwallet-proivder` now has a `prefund` option that automatically funds the eth-lightwallet accounts with wei from the coinbase of the connected node, which simplifies the process of running tests in TestRPC. Contest was also updated to add `timeout` options (for longer-lasting test cases), and now comes with tempo as standard (`wait`), and contract tests were updated to implement it. An internal wiki was populated, centrally documenting the entire toolset.

    We were admitted to the Microsoft Bizspark program, who’ve kindly provided us usage and support of their Azure platform. I did some node deployments for use with Spectrum; deploying TestRPC node (for ultra-fast live demos) and private ropsten/mainnet deploys for advanced debugging (which infura is currently lacking).

    Spectrum development continues and watertight best practices for the complex data store have been identified and that will be the focus of this week’s sprint. Completing this integration (which was set back due to DGX 2.0 tooling upgrades) will allow for the addition of more complex account types and a standardised API for interacting with dapplets.

    Weekly Commit Report

    # Project github.com:DigixGlobal/contest - b7dec7f — [feature] implement `wait` - 883b128 — [feature] add `timeout` setting

    # Project github.com:DigixGlobal/core2-storage-library-contracts - babbf78 — [feature] convert tests to CACP - 4351eec — [maint] add ContractResolver deployment - 2b93814 — [maint] update contest - fa12f13 — [maint] sync config with solidity-core-libraries - ab8fec2 — Merge branch ‘system-refactor’ of github.com:DigixGlobal/core2-storage-library-contracts into system-refactor - 326fa74 — [maint] sync up to boilerplate standard

    # Project github.com:DigixGlobal/solidity-boilerplate - f28c637 — [maint] update readme - aa406b7 — [maint] use `networks — clean` - e771dba — [maint] migrate to truffle 3.0 & various dependancy updates

    # Project github.com:DigixGlobal/solidity-core-libraries - 70d2829 — [maint] update deps (fixes console deployed() issue) - 464cb60 — Merge branch ‘master’ of github.com:DigixGlobal/solidity-core-libraries - d2dafb5 — [maint] update to use contest with timeout feature - 9a3d963 — [maint] update readme - f3c184f — [maint], update and document `npm run` commands - 0c128c4 — [maint] bump version - 92f5c33 — [maint] gitignore env.sh

    # Project github.com:DigixGlobal/truffle-lightwallet-provider - 1896b8b — [bugfix] fix `getAccounts` by having lightwallet added before rpcProvider… - 26b8e43 — [maint] v0.0.7 - 1233a38 — [maint] document `prefund` - 932664e — [feature] `prefund` option - 82afc9a — [feature] ensure all RPC errors are properly logged - 9e9e282 — [maint] remove superfluous `send` (not supported by web3ProviderEngine) - d038928 — [bugfix] don’t initialize unless send/sendAsync method is called - ec9dd7f — [bugfix] don’t log debug for first request `_fetchLatestBlock` - 1faa7aa — [feature] add rpcUrl to debug - 0a43591 — [feature] better error messages, drop unused subproviders - 30e72f5 — [bugfix] use `engine.start()` to to ensure polling is working - 977f21e — [maint] update readme w/ sigmate reference

    # Project github.com:DigixGlobal/truffle-contract - 29d8151 — Merge branch ‘fix-deployed-in-console’ into digix - ac6e40f — [bugfix] fix `deployed()` ‘auto-resolve’ in console - c9b82fb — [bugfix] reject promise rather than throw in `new` - 3b432ea — [bugfix] use a custom `new` method for deployments for infura compatability

    # Project github.com:DigixGlobal/doxity - 52989fd — [maint] add notice about truffle integration

    # Project github.com:DigixGlobal/truffle-console-helpers - 2bd9cc5 — [feature] initial commit; `tempo`

    # Project github.com:DigixGlobal/digix.io-v2 - ff6e762 — [maint] update address



  • Updates from the CTO — 15 Feb 2017

    For the past three months, the development team Digix has been working to complete the DigixCore 2.0 platform, and I am happy to say that we are now within two weeks of making our contracts available on the public test net. The Ropsten release will allow us to test our contracts further and give our technical partners and third party services time to integrate our services.

    The last few months have been quite a learning experience for our team. The path to creating products on top of bleeding edge technology is wrought with many pitfalls — learning 3rd party development tools which are arguably still in their early stages of development, understanding the security pitfalls, deploying to a unique execution environment with its own set of quirks such as:

    • Contract binary size limitations
    • Stack depth limits
    • Inter-contract calling conventions that can introduce race conditions

    In traditional systems and web programming, developers have a wealth of prior knowledge which they can draw from. Books such as Design Patterns: Elements of Reusable OO Software from the “Gang of Four” are great classical troves of information on how to build large software projects. These are luxuries that a smart contract developer on Ethereum does not have at this point in time.

    In the past few months, I have spent a great deal of time thinking about what topics a book entitled “Design Patterns: Elements of Secure Ethereum Smart Contract Software” would contain. One result of this exercise was the development CACP/ICS which I had presented at DEVCON2. I have since refined these into CACP/ICS 2.0 which suggests stricter rules for data flow and inter-contract calling conventions. I am in the process of distilling this information into a 60 to 90-minute presentation for future public talks.

    Proposed Public Testnet Schedule

    Task and Level of effort

    DigixCore 2.0 on Ropsten 10–14 days

    DigixDAO SimpleVote on Ropsten 4 days

    DigixGold Marketplace for Ropsten 21 days

    Third party code review~45 days

    Launch Considerations

    While we are very eager to launch or services to the public we need to take a prudent approach. We have to acknowledge that Ethereum is still undergoing many changes as part of its growth process. Potential future changes to the EVM that introduce hard forks need to be taken into serious consideration in our existing design as to allow us to migrate with the least amount of headaches.

    Migration Consideration for Digix 1.0 Users

    Existing Digix 1.0 customers will need to upgrade their lightwallet to the new version using our migration tool. As the amount of tokens and asset cards that were purchased during our beta were minimal we will be manually migrating them to DigixCore 2.0. Any storage fees due on existing Digix gold assets will be reset to 0. Transaction fees that were collected will be sent to the DigixDAO TokenBank for future disbursement to DigixDAO token holders.

    What is DigixCore 2.0

    DigixCore 2.0 is the umbrella project consisting of the following components and functionalities:

    • Digix Proof of Asset Registry
    • Digix Gold Assets
    • Digix Gold Tokens
    • Asset Minting into Tokens
    • Recasting tokens into Assets
    • DigixDAO Transaction Fee/Demurrage Rewards
    • Digix TokenBank

    Additionally the following will be made available during the main network launch:

    • Spectrum based lightwallet to store DGX gold tokens and gold assets.

    DigixDAO token holders will start accruing DGX gold token rewards from transaction and demurrage fees starting on day one after we officially launch. Furthermore, previously collected transaction fees from the Digix 1.0 platform will be sent to the DigixDAO token account which will be made available for withdrawal during the first quarterly claim period.



  • DigixGlobal and Monolith Studio announce a strategic partnership to create a secure DGX powered TokenCard

    First Look at Monolith’s Gold Token Card

    We’re excited to announce a partnership with Monolith Studio. The initial focus of the partnership is to create a one-of-a-kind debit card based in Digix DGX gold tokens. The yet to be named ‘Gold card’ ties into the transaction based profit models of both DigixDAO and Monolith’s TokenCard. The effort attempts to vastly extend the reach of Digix’s tokenized commodities to the general public by lowering the barrier of entry and offering unique functionality.

    Monolith Studio recently unveiled plans for TokenCard: an Ethereum powered debit card that can hold ERC20 tokens. This DGX powered version allows users to leverage TokenCard’s next generation security features whilst using a familiar commodity as a store of value. TokenCard and Digix can together bring back the gold standard in a meaningful way.

    TokenCard will be a crowdfunded platform, with an underlying token: TKN. TKN accrues a 1% licensing fee on every transaction made with TokenCard and gives holders various perks. The crowdfund is set to commence on March 20th.

    You can read more about TokenCard here at http://monolith.ventures/token...



  • DGX Gold Tokens alpha-1 on Ropsten public testnet

    This week we deployed alpha-1 of our DGX Gold Tokens on the Ropsten public testnet. If you are interested in playing around with some test tokens you can add the following ERC-20 configuration on your Mist, MyEtherWallet, or any ERC-20 compatible token wallet that points to a Ropsten provider.

    Token Contract Address: 0x1e83ddddc7826f8804630af70935f68090295d38 Token Symbol: DGX-alpha-1  Decimal Places: 9

    Please provide a Digix team member with your Ropsten wallet address so we can send you some test tokens.

    Exchanges and developers looking to develop 3rd party contracts that interface with our tokens will now be able to test integration.

    What works now

    - Token transfers - Token transfer approvals - Daily demurrage calculation and collection - Transaction fee collection

    What does not work yet

    - Recasting

    Digix Gold Asets

    We are now in the process of migrating prototype code from our prototype repository into the DigixCore 2.0 project repository. Once this is completed we will deploy a new instance of our contracts on the Ropsten testnet which would provide the following functionality:

    - Recasting of tokens into assets - Minting of assets into tokens - Transfer ownership of assets - View asset information - Pay storage fees

    Weekly Commit Report

    ### Project github.com:DigixGlobal/digix.io-v2 - 2ed12e6 — [maint] add monolith announcement - ff6e762 — [maint] update address

    ### Project github.com:DigixGlobal/doxity - 52989fd — [maint] add notice about truffle integration

    ### Project github.com:DigixGlobal/solidity-boilerplate - 31d8b65 — [maint] use yarn, update deps - f28c637 — [maint] update readme

    ### Project github.com:DigixGlobal/wallet-migration - adf69e2 — [bugfix] enable download in firefox; fixes #1

    ### Project github.com:DigixGlobal/solidity-core-libraries - a133534 — Merge branch ‘master’ of github.com:DigixGlobal/solidity-core-libraries - d8678cf — [maint] ignore yarn-error.log - dbc05c0 — [maint] update yarn.lock - a5be70a — [maint] bump package version - 273d76c — Merge branch ‘master’ of github.com:DigixGlobal/solidity-core-libraries - 49eef4d — [maint] rename function parameters to use more appropriate terms - d98a8f1 — [maint] rebuild yarn.lock with latest yarn - 7831807 — [maint] bump version - d2ea141 — [maint] fix truffle, truffle-compile, use `yarn.lock` - f8a0df4 — [maint] use truffle beta to fix compile issues - 33c3af7 — [maint] Bump npm version - 2e745dc — [feature] factor out demurrage calculations - 426fe7e — [feature] update demurrage calculations to show balance after

    ### Project github.com:DigixGlobal/cacp-contracts - ddcefa3 — [maint] use yarn, update deps, rebuild

    ### Project github.com:DigixGlobal/core2-storage-library-contracts - 0aa8724 — [maint] rename User library to Token library - 99abef5 — [feature] Ropsten alpha deployment - 8902055 — [feature] log approvals - 64f4f64 — [maint] remove default minting in constructor - 17236de — WIP on master: 2e8f0f8 [feature] Simple minter - 4ded1c1 — index on master: 2e8f0f8 [feature] Simple minter - 2e8f0f8 — [feature] Simple minter - 1d441df — [feature] Transfer From and Approvals - 6094eb2 — [maint] remove yarn for now - e6753e0 — [hotfix] fix demurrage calculation and deduction - 078339b — [feature] add CACP controller skeleton - f36ec80 — [maint] use yarn, update deps - 10f001a — [feature] token transaction function - 050cf25 — [feature] storage and controller demurrage functions - 654ae41 — Merge branch ‘master’ of github.com:DigixGlobal/core2-storage-library-contracts - babbf78 — [feature] convert tests to CACP - 4351eec — [maint] add ContractResolver deployment



  • Digix Core Dev Weekly Update — Mar 1st 2017

    By, 

    KC Chng (CEO)

    Ropsten Hiccup

    On 24th Feb 2017, Ropsten, Ethereum’s public test net, was under a denial a service attack (“spam attack”). Average block propagation time slowed to a crawl as a large miner has decided to deploy several zero-value high-gas transactions to spam the test network continually. The attacker’s intentions are unknown, but the result is that Ethereum developers who rely on Ropsten to test their contracts no longer have a stable public testing environment to deploy and test their smart contract code prior to deploying to production.

    The use of Proof-of-Work (PoW) for testnets presents a fundamental game theoretical problem: the only significant economic incentive to mine on testnets using dedicated GPU resources is to launch an attack and reduce stability and the viability of the testnet (and thus hamper development for the mainnet chain).

    This means that testing on Ropsten may no longer be viable as these attacks will come continually / sporadically. We are working out alternatives as we speak, and will make a separate announcement soon.

    Chris will be giving a presentation tomorrow at SG Innovate, together with Attores and Otonomos. Please tune into our channel for more information.

    Digix Live Stream

    Chris Hitchcott (Digix Core Dev)

    This week I’ve been working on Spectrum. I completed the web3-redux refactor, and have implemented `redux-orm` as the main datastore for the core project. This gives us the ability to have dynamic keystore ‘plugins’ with custom creation, editing and signing components. In simple terms, this means that adding new signing types (like uPort or 2FA) can be done in a decoupled way, and the ‘dapplet store’ can not only list dapplets, but also custom keystore providers.

    Weekly Git Commits

    ## core2-storage-library-contracts ###git@github.com:DigixGlobal/core2-storage-library-contracts.git

    - b95c7a4 — [maint] refactor into single storage contract - 586ecbf — [wip] Auditor and Custodian functions - 729f490 — [wip] Vendor related functions - 9b2e271 — [wip] participant interfaces and controllers - 0aa8724 — [maint] rename User library to Token library - 3f85527 — [wip] Asset contracts

    ## simple-faucet ###git@github.com:DigixGlobal/simple-faucet.git

    - 6bc5add — [maint] add example start script for localhost server - a44052c — [feature] resolve ip in new version of nginx, document - a8ac441 — Merge branch ‘master’ of github.com:DigixGlobal/simple-faucet - 0c5217c — [feature] simple faucet — initial commit - 2c0cf57 — Initial commit

    ## spectrum ###git@github.com:DigixGlobal/Spectrum.git

    - a9a0f25 — [wip] offline signing - b19c9c7 — [wip] modular hooked signing providers 😆 - 9b44e38 — [wip] parse balances with bignumber - 5e3e6d9 — [wip] more sensible v3 editor - 6f83fd0 — [wip] web3 integration - 156ddaa — [wip] tokens refactoring - 34ad1e3 — [wip] working baseToken tx signing 🍻 - 033ed79 — [wip] full CRUD for v3 and cold - 5a307a6 — [wip] create `keystore_modal` that wraps creation and editing - d168303 — [wip] hook up web3-redux and keystore_edit modularity - 66c6bbd — [wip] token and balance listings - c5c3621 — [wip] network chain ID & blockchain prefix - ff11555 — [wip] Sexy token CRUD - 83dcd6f — [wip] minor UX fix - 42cee34 — [wip] better hot loading - 424f0d7 — [wip] UI tweaks - 947b914 — [wip] generate v3 wallets - 44434c1 — [wip] modular keystore creation 👏 - 8744304 — [wip] major clean up - 902c837 — [wip] bump iteration count - 63b8997 — [wip] relational keystores, keystoreTypes & networks - a26b975 — [wip] implement redux-orm for networks - 14ba3df — [wip] web3-redux base token transactions - 34d510e — [wip] implement pending requests - 1644df9 — [wip] full network sync with web3redux

    ## web3-redux ###https://hitchcott@github.com/DigixGlobal/web3-redux.git

    - e5fbc40 — [bugfix] merge contract calls - 65f96f5 — [bugfix] ensure waitForMined has a blockNumber - a6ac364 — [wip] merge transaction data - 54c9c10 — [wip] implement total & networks pending - 3ed5861 — [wip] implement connection status - bc63ede — [wip] contracts completed - c6b2b6b — [wip] reactor action creators - 6d9308e — [wip] generateContractApi - cd8c9c9 — [wip] getTransaction - 11739d6 — [wip] implement transaction creation - efb29d5 — [wip] implement web3 setter/getter - 99cba45 — [wip] allow passing actions, cached generateNetworkApi setup - e9c5710 — [wip] implement basic connect model - ea90350 — [wip] boilerplate example project for v2

    ## sui-react-ezmodal ###https://hitchcott@github.com/hitchcott/sui-react-ezmodal.git

    - 456dcc6 — [feature] setFormData - 9aab1c0 — [feature] onReset - fdca4ec — [feature] error message - 3929cfb — [feature] add `resetFormData`

    ## report-script ###git@github.com:DigixGlobal/report-script.git

    - 41093ac — [bugfix] show repos with 1 commit - b20131f — [feature] initial commit — git report script



  • Announcing Kovan — A Stable Ethereum Public Testnet

    The ten organisations that collaborated on Kovan testnet are:

    • Digix — Asset Tokenisation Platform
    • Etherscan — Ethereum Block Explorer
    • Parity Technologies — Developer of the Parity Ethereum Client
    • Attores — Smart Contracts as a Service Provider
    • Maker — Stablecoin Platform
    • OneBit by TenX — Real world payments with Blockchain Assets
    • Blockchain Industries — Blockchain Consultants
    • MelonPort — Digital Asset Management Platform
    • Nivaura — Financial Instrument Issuance and Administration Technology
    • GridSingularity — Decentralized Energy Data Application Platform

    In line with the Morden and Ropsten naming convention, Kovan is named after a metro station in Singapore — home of Digix, Attores and TenX — where the initial proposal for the Kovan public testnet was drafted at the SGInnovate co-working space. For information on connecting to the live Kovan testnet and using the faucet service, please read the configuration guide at, or join the gitter channel for support.

    Parity pushes new Ethereum testnet Kovan after spam attacks
    Parity, Digix and Melonport are among a group of 10 Ethereum companies launching Kovan, a new public testnet for…www.ibtimes.co.uk




  • Letter from the CEO — Some Context Regarding Kovan

    With the recent announcement of the Kovan testnet, there’s been some backlash about why and how it was launched, and we wanted to add our perspective to hopefully provide some context to the discussion.

    From what we’ve read, there seems to be some accusations about the intent and organisation of the Kovan testnet. There also appears to be a misconception that Gavin Wood (from Parity Technologies, formerly known as Ethcore) hasspearheaded and developed the technology specifically for the launch of Kovan (dubiously dubbed “Ethcore’s testnet”). This isn’t accurate. Kovan is a grassroots initiative that in reality had initially little to do with the Parity team.

    We wanted to set the record straight by explaining a little bit more about the genesis of Kovan, in an attempt to defuse some of the bitterness that it’s release has caused. We think that context really matters here, as does the intent behind Kovan.

    Here’s the TL;DR:

    • Parity’s Proof of Authority engine wasn’t created for Kovan; it was apublicly available option (https://gitter.im/ethcore/parity-poa) since the 1.5 release of Parity, well before the Ropsten attacks began
    • After the Ropsten attacks, a group of Ethereum developers in Singapore came together to try and come to a solution
    • With knowledge of the PoA option, we decided to form a quick group with some other trusted parties we knew personally
    • Kovan wasn’t Gav’s idea. He agreed to be a validator at our request. It was a proposal Digix, Attores and TenX originally drafted at SGInnovate as we needed a quick solution to a working testnet as stated in the news release
    • Kovan is and will continue to be a grassroots effort by a diverse group of private, independent Ethereum development teams as stated in the news release.
    • Kovan doesn’t need to replace Ropsten; it’s an optional alternative — a free public service for the Ethereum community that’s open to everyone, intended for user acceptance testing and integration with our partners
    • Kovan was launched with the best of intentions in the interests of the Ethereum community

    We at Digix recently announced that we’d be launching our contracts on the Ropsten testnet, which we did, but continued deployment was quickly interrupted by the recent “spam attacks” that began around Feb 24th.

    Chris from Digix got talking with Gaurang from Attores, and they came to the conclusion that PoW was basically unviable for testnets; if malicious actors can get their hands on “monopoly money” testnet ETH by mining, then spam attacks will be a persistent concern for any PoW testnet.

    We had made commitment to our clients to deliver on the testnet within weeks. As no other announcements had been made from other organisations about a solution, we figured we were on to something, and it would be awesome to provide a service to the community by setting up a public testnet running PoA — a technology we had recently learned about from the Parity 1.5 release in January. We just needed a small network of organizations to launch a test net asap, make the network publicly accessible, and have some secure faucets in place to prevent malicious actors from getting testnet Ether. The idea of Kovan was born.

    Within 24 hours we had organised a collaboration between various parties, got in touch with our friends at Etherscan (who kindly agreed to be on board; you need a quality blockchain explorer if you’re creating a public testnet), wrote up a proposal, and reached out to Gav about helping us create a config file for parity.

    Note that even if Gav wasn’t on board,we still would have launched Kovan.Infura actually did the same. The ability to use Parity’s PoA (https://gitter.im/ethcore/parity-poa) wasn’t a secret, and anyone could have done what we did with or without Gavin’s help.

    Within a week, we coordinated the relevant discussion channels, refined the proposal, produced a user guide, and got everyone on the same page with all the Authorities running validator nodes (at their own expense). Even the block explorer was set up and was good to go. Kovan was ready to launch within a week of it being first conceptualised, and we had press release ready with our PR channels ready to push out for the Monday news cycle.

    So that’s the context — a group of private organizations, with a proposal first written up out of the SGInnovate offices, coming together to solve a problem that was blocking our progress. There was no intention to hurt anyone’s feelings which technology was used — it’s just that at the time Parity was ready to go as the only real option to launch a PoA public testnet as soon as we can.

    Thankfully, the launch of Kovan has also spurred on the publication of similar initiatives from the Ethereum Foundation to create a standardised PoA-based testnet, and we’re glad that the launching Kovan has helped push things forward.

    We hope this recent drama doesn’t get in the way of progress — we won’t be commenting further on it. At the end of the day, we just wanted to get back to building dapps, and with Kovan, now we can.



  • Digix Dev Update — Mar 10 2017

    Since we last spoke just over a week ago, a lot has happened. As a solution to the Ropsten spam attacks, with the help of a few friends, deployed an entire new testnet called Kovan. With regards to Kovan, we helped write most of the documentation for users and validators, and have been helping out with the faucet service (simply sending those who request KETH to them when they need it).

    We also redeployed our entire existing contract codebase to Kovan, with the addition of the Asset Vendor Interface (the contracts that allow gold bar vendors to register new bars). Thanks to the recent truffle upgrade, it was a simple as a minor config file update and we were good to go re-deploying and importing the contract metadata via NPM into any kind of app we wanted.


    Truffle config for kovan


    Registering the first asset bar on Kovan

    Amongst other Spectrum features, I’ve been working on the associated user interface to allow vendors to register bars. Web3-redux has helped out a lot in with writing the UI — getting data from the blockchain and creating transactions whilst transparently hooking into the signing UI based on the type of account that the address is associated with.

    Importing AssetVendorInterface contract info generated by truffle directly from NPM

    Creating the asset transaction, automatically showing signing modal





    Work in progress user interface for vendors to register assets

    ## core2-storage-library-contracts

    ### git@github.com:DigixGlobal/core2-storage-library-contracts.git

    - 9bc809b — [maint] add deplyoed addresses to readme

    - ed3a52a — [maint] move contract deps to devdeps

    - e287632 — [maint] update truffle deps, update gas for kovan

    - 8b64192 — [maint] redeploy to kovan

    - b11dd4e — [wip] asset redemption

    - 8d73b71 — [maint] merge with build

    - f477af2 — Merge branch ‘alpha2’

    - b5feec3 — [maint] remove build pre-merge to master

    - bc04f7d — [maint] merge issues

    - 8054a33 — [maint] merge issues

    - c1fd002 — [bugfix] Fix compile issues after merge

    - 06e68ae — Merge branch ‘alpha2’

    - ec1171b — [wip] AssetVendorInterface

    - 732d7e4 — [wip] Asset vendor

    - 5624f31 — [feature] Asset vendor interface

    - 1fc857a — [maint] deploy to kovan

    - 652c632 — [wip] AssetInfo and AssetData refactoring

    ## digix.io

    ### git@github.com:DigixGlobal/digix.io-v2.git

    - 24d2944 — [maint] Build

    - 3054328 — [maint] Use new blog feeds API endpoint

    ## gfx

    ### git@github.com:DigixGlobal/gfx.git

    - 81d55dc — [maint] add dgx test token

    ## spectrum

    ### git@github.com:DigixGlobal/Spectrum.git

    - 09f8c4d — [wip] vendor assets ui

    - 83abe0b — [maint] add additional stringUtils; isPrefixed, toRednerable, isNull, hexToNumber

    - 3b52ace — [wip] keystore import

    - e792c91 — [wip] use updated web3-redux for hot reloading

    - d39b620 — [wip] update seedStore with kovan, misc cleanup

    - 37e77a3 — [wip] v3 keytore download

    - cef8a78 — [wip] cold storage signer (w/ qr code)

    - bbb49ef — [bugfix] hide signing modal

    ## truffle-lightwallet-provider

    ### git@github.com:DigixGlobal/truffle-lightwallet-provider.git

    - 0d76b2e — [maint] use re-enable polling for comptability with updated truffle

    ## web3-console

    ### git@github.com:DigixGlobal/web3-console.git

    - b77eb01 — [maint] update readme

    - e031dcf — [feature] intial commit — web3-console

    ## web3-redux

    ### https://hitchcott@github.com/DigixGlobal/web3-redux.git

    - e5133de — [feature] for multiple return values, return object with de-prefixed names

    - 339759e — add `isConnected`

    - 18a9623 — [minor] linting fix

    - 7f723ae — [feature] expoose raw connect handlers for HMR



  • Digix and Blockchain at UC-Berkeley to run 1 day workshop for Developers on Ethereum — Apr 2

    UC Berkeley’s Blockchain at Berkeley (B@B) has partnered with DigixGlobal to run a 1 day workshop on Ethereum Smart contracts. B@B is a student initiative providing computer science and engineering students with in-depth knowledge of blockchain development. This collaborative workshop is designed to introduce developers to the tools and opportunities that Digix provides and familiarize them with Digix’s vision for the future of blockchain development. Digix is an asset tokenization platform based out of Singapore and built on the Ethereum blockchain. They have spent the past 2 years developing open sourced tools and design patterns to make this fast paced space more accessible and enable developers to build new and innovative things.

    Jonathan Allen, Co-Head of Consulting at B@B, says that “After noticing the unmet need in the industry for blockchain developers and entrepreneurs, we decided to start Blockchain at Berkeley and provide students with the requisite knowledge they need to succeed. We believe DigixGlobal, as a leading player in the space, will bring a wealth of knowledge and creativity that will inspire our members to develop projects they would not have come up with otherwise.”

    Once students are familiar with the Digix development platform, they will be encouraged to come up with ideas and projects that utilize the Digix ecosystem. This workshop will provide hands-on experience for students to help them understand the current capabilities offered by Digix tools.

    More information about the workshop can be found at facebook, B@B website, or Meet-up.

    The workshop will be live streamed on B@B Facebook page at the time of the event.

    Ronen Kirsh, Co-Head of Consulting, says that “After our first talk with Kai (Digix’s Co-Founder and CEO), we noticed there was an immediate alignment between the culture and aspiration of Blockchain at Berkeley and that of DigixGlobal, which is to create an ecosystem that voluntarily cooperates and work together for synergies. With similar goals and both organizations being extremely motivated to create an ecosystem of progress in this highly technical space, a collaboration makes perfect sense.”

    Digix’s vision right from its inception was to help build a community and ecosystem on ethereum. This workshop fulfils a part of this vision and creates a pool of developers well versed in our open sourced tools.


Log in to reply
 

Looks like your connection to Cryptocentral was lost, please wait while we try to reconnect.