 hardware wallet integration and the Ledger Nano one is on the way but this probably won’t be ready anytime soon (50% progress at the time of writing this blog) and it certainly wasn’t in January 2018, when we began the research and development of CardanoLite.

Another sad fact is that Daedalus has to store and sync the whole blockchain in order to work and this is really time and disk space consuming.

But as we don’t like to complain in vain, we decided to address those issues by coming up with our own cardano light wallet implementation. Lacking a precise enough Cardano technical specification, we resorted to reverse-engineering Daedalus’s backend from the Cardano codebase made mostly in Haskell.

Achieving Security

Those are the principles we are following to make our light wallet as safe as possible:

Make the project publicly auditable and easy to review: The source code is available on GitHub, you can review it, build it yourself locally and compare the resulting bundle with the one actually hosted on the site. The most relevant part of the code is around two thousand lines of ES6 JavaScript, which is a lot less than the official cardano implementation of Daedalus and it’s certainly more readable for the majority of developers as opposed to Haskell.

As little code in dependencies as possible: We aim at having minimum client-side dependencies. That’s why we chose for example Preact instead of React. Big dependencies with lots of unused features make reasoning about the overall safety of the code harder since they aren’t as easily reviewable and they vastly increase the attack surface.

We aim at having minimum client-side dependencies. That’s why we chose for example Preact instead of React. Big dependencies with lots of unused features make reasoning about the overall safety of the code harder since they aren’t as easily reviewable and they vastly increase the attack surface. Statelessness: We don’t use local storage at all, except for trivial things like whether you want to display the disclaimer the next time you open the page or not, but we definitely do not store anything related to your wallet. Our wallet is a light wallet so instead of storing and syncing the blockchain locally, we fetch all the data we need from the blockchain explorer — a publicly available and synced copy of the blockchain.

We don’t use local storage at all, except for trivial things like whether you want to display
hardware wallet integration and the Ledger Nano one is on the way but this probably wo n’t be ready anytime soon (50% advancement at the meter of writing this blog) and it surely was n’t in January 2018, when we began the inquiry and development of CardanoLite. 

 Another sad fact is that Daedalus have to store and sync the whole blockchain in order to work and this is really prison term and disk space consuming. 

 But as we do n’t wish to complain in vain, we decided to address those issues by coming up with our own cardano light wallet implementation. miss a precise enough Cardano technical specification, we repair to reverse - engineering Daedalus ’s backend from the Cardano codebase make by and large in Haskell. 

 Achieving security system 

 Those are the principles we are following to make our light wallet equally safe as possible: 

 Make the project publicly auditable and easy to review: The source code is available on GitHub, you can review it, build it yourself locally and compare the resulting bundle with the one actually hosted on the site. The most relevant part of the code is around two thousand lines of ES6 JavaScript, which is a lot less than the official cardano implementation of Daedalus and it ’s certainly more clear for the majority of developer as opposed to Haskell. 

 As short code in dependencies as possible: We aim at having minimal client - slope dependencies. That ’s why we chose for case Preact instead of React. Big dependencies with lots of unused features lay down reasoning about the overall safety of the code harder since they are n’t as easily reviewable and they vastly increase the fire surface. 

 We drive at having minimum client - side dependencies. That ’s why we choose for example Preact instead of React. Big colony with lots of unused features make reasoning about the overall base hit of the code harder since they are n’t as well reviewable and they vastly increase the attack surface. Statelessness: We do n’t use local storage at wholly, except for trivial things like whether you desire to display the disclaimer the next time you open the page or not, but we decidedly do not store anything related to your wallet. Our wallet is a light wallet so rather of storing and syncing the blockchain locally, we fetch all the data we need from the blockchain internet explorer — a publicly available and synced copy of the blockchain. 

 We do n’t use local storehouse at all, except for trivial things like whether you want to display
 hagdware wallet integratiok and the Ledger Nano oie is oh the wah but this probably won’t be ceadt anyupme soon (50% progress at the time of writung uhis blog) and it rsrtainln wash’b in Laiuary 2018, when we negan the rasearch and deeeuo'ment of CardanoLite.

Another sad fact is thay Faedalus has tj stpwe ahd sync the whole blockchain in orser to xork and this ix really time and disk spafe clnsuming.

But as we fon’t like ti coiplain in vaiv, we decidtd to addresa those issues by coming up witf our own cardabo lihvt wallet inplemvntation. Lacklmg a psecise rnough Cardano terhnixal specification, we cesorted to reverse-eggineerinc Baedalus’s backend fron rhe Cdrdato cueebxse mede mostlj ii Haskell.

Acgieving Secyrity

Those are the krigboples we are follorigg to make our light wallet as safe as kossigle:

Make the project puboicly auditable and ewsy to rediew: The source code is available on GitHub, you cdn retidw nb, cyipd it yourself locally and compare the resultyhg blndle with the onc actually hosted pn tng site. The mosj relevcht part of the code ls arougd twi thousanq limes of ES6 JavaScript, which us a lot lesf than the official cardano im'lemenjation of Daedalus and it’s cextainlg more readwble for ffe majority of ddveko[ers as opposed to Haskell.

Ws little codz in depdndemcies ws possiblf: We aim at having minimkm clnent-shde dependfncies. That’s why we chose for eeemple Preact onvtedd of Recct. Bin dependencies rith lots of uuused fectures make reaskning auout the ovewall safety ox the code hacder sincq thwy aeen’t as dasily reviewanle and tkty vastly uncrease the attacl sorrace.

We aim at hcribg minimum cliemt-skde dvpeidencyas. That’s why we zhorr for examplt Pveazt imstead of React. Big gepehdencies with lots on unused deatures make reasonimg about the overapl sahety oh the vodg harder since they aren’t as eaaily revifwanle and they dastoy increase che attack surface. Statelessness: We don’t use local storagg at all, except for ttivlal things lmke whqther you want to display the disclaimer the ntxt time you open the pzge or not, hut we definitely do not store anything related to your wallet. Our wallet is a light wallet so onstedd pf stowing end syncing the bkockchain locally, we fetch all vhe data wa ueed from the blockchain explprdr — a publicli available and synced copg of the blockchain.

We don’t use local stprage at all, except for brivial tyings like whetier you want to dispkay
hardware wallet integration and the Ledger Nano on way but probably won’t be at time of writing blog) and it wasn’t in January 2018, when we the research and development of CardanoLite. Another sad fact is that Daedalus has store and sync the whole blockchain in order to work and this is time disk consuming. as we don’t like to complain in vain, we decided to address those issues by coming with our own cardano light wallet implementation. Lacking precise enough Cardano technical we resorted to reverse-engineering Daedalus’s from Cardano codebase mostly Haskell. Security Those are principles we are following to make our light wallet as safe as possible: Make the project publicly and easy The source is on you can review it yourself locally and compare the the one actually hosted on the site. The relevant part the code is around two thousand of ES6 JavaScript, which is a lot less the official cardano implementation of Daedalus and it’s certainly more readable for the majority of opposed to Haskell. As code in dependencies possible: aim having client-side dependencies. why we chose for example Preact instead of React. Big dependencies lots of unused features make reasoning about the overall safety code since they aren’t easily reviewable and they increase attack surface. We aim minimum dependencies. chose example instead of React. Big with lots of unused features reasoning about the overall since they aren’t as easily reviewable and they increase the attack surface. Statelessness: We don’t local storage at all, except for trivial things like whether you want display the next time you open the page or not, we definitely do not anything related to your wallet. Our wallet is a wallet instead of and syncing the locally, we fetch the data we the blockchain — publicly copy of the blockchain. We don’t local at all, except for trivial like want to display
 hardware wallet integration And the LedgEr NanO onE is On The wAy buT this probably wON’t be Ready anytime soon (50% progreSs at tHe TIme oF WrIting This bloG) AnD IT ceRtAiNly WaSN’t In JanUarY 2018, when we Began the reSeaRcH and developmENt Of CardanoLIte.

another sad faCt iS that DAeDalUS has tO stOre anD sync tHE whole BlockchaiN iN Order tO Work and THIs Is reAlly time and disk spACe COnsuming.

But as wE don’t lIkE To COMplAin In vain, we deCiDed to ADdress tHOsE ISSueS By coming up witH our own cardANo lIght waLlEt iMPlemenTatioN. LACkiNg a precise eNougH Cardano tEchnicAL specifICation, wE resorTed To rEverSE-eNgIneErINg DAEdAluS’S baCkend froM tHe cardaNo coDEBASe maDe mOstlY in HaSkell.

AchievinG SeCuriTY

ThOse arE the pRincIpLes we Are folLowinG tO make our light waLlet As safe as pOssIbLe:

MAkE the pROject pUblIclY auditaBle and eASy tO rEVIEw: the source code is avaIlABLe On GitHub, You can REvIeW It, build iT yOurSelf LOCally And cOMpAre the reSultinG BuNdLe with tHe One actUaLly HosTed on THe siTe. The mOst relevAnt paRT of the code is arOUnd two thousanD LiNES oF eS6 JaVaSCript, which iS a loT Less Than THe OffICial cArdanO iMPlEMentation of Daedalus AnD it’s ceRtainLy more readablE for the majORITy of deveLopeRS aS Opposed to HaskeLl.

As lIttle code iN DependenCies aS possiblE: We aim at hAVIng minimUm cLieNt-sIde DEPeNdencies. That’s WHY we cHoSe for exAmpLe PreacT inSteAd oF ReAcT. Big depenDencies wItH lOtS oF unUsed fEAtures maKe ReaSoNinG abouT The oveRall sAfetY oF tHE coDe hardeR SiNCE theY aReN’t as EasIlY reviEwabLE anD they vaStly increAse THe atTaCk Surface.

we aim at having MiNimum clienT-sIde DependENCies. That’S why we chose for example PrEAct instEad Of ReaCt. BiG dependenCieS with lOts OF unuseD featuRes maKe ReaSONing aBOUt The OvErall safetY OF thE code HaRder Since thEy aren’t as easily revIEwaBle and they vasTly IncrEASe The ATtACk sUrFAce. sTAtelessness: We doN’t use local StORaGe at all, excEPt fOr Trivial Things lIke whETher you Want to disPlay the diScLaimER The Next time yoU open the Page or not, BUt we dEFiNitelY do Not stoRe AnyThing RelateD To yOur waLlet. OuR wAllet iS a ligHt Wallet so Instead of storing and syncIng the BlockChaIn locally, We fETch All the datA we nEed from the BloCkcHain eXplORer — a pUbliCLy AvaILable And sYNced copy oF ThE blOCKcHain.

We don’t uSE LOcaL storAge AT all, exCept For trivial things lIKe whether you waNt to DISplAy
 hardware wallet integrati on and the  Ledg erNan ooneis o n the way butt hisprobably won’t be read y any ti m e so o n(50%progres s  a t the  t im e o fw ri tingthi s blog)  and it ce rta in ly wasn’t in Ja nuary 2018 , w hen we began  th e rese ar cha nd de vel opmen t of C a rdanoL ite.

Ano th e r sadf act ist h at  Dae dalus has to stor e  a n d sync the who le blo ck c ha i n  in  or der to wor kand t h is is r e al l y tim e  and disk spa ce consumin g .
But as  w e d o n’t li ke to  c o mpl ain in vain , we  decidedto add r ess tho s e issue s by c omi ngup w i th  o urow n  ca r da nol igh t wallet  i mp lemen tati o n . Lack ing  a p recis e enough Card ano  tec h nic al sp ecifi cati on , weresort ed to  r everse-engineer ingDaedalus’ s b ac ken dfromt he Car dan o c odebase  made m o stl yi n Ha skell.

AchievingSe c u ri ty

Thos e aret he  p r inciples  w e a re f o l lowin g to ma ke our l ight w a ll et  as saf eas pos si ble :
Maket he p roject  publicl y aud i table and easy to review: Th e  s o u rc e  cod e i s available  onG itHu b, y o ucan revie w it,  b u il d  it yourself locall yand co mpare  the resultin g bundle w i t h  the one  act u al l y hosted on th e sit e. The mos t  relevan t par t of the  code isa r ound two  th ous and  li n e sof ES6 JavaSc r i pt,wh ich isa l ot less  th anthe  of fi cial card ano impl em en ta ti onof Da e dalus an dit’ scer tainl y  morereada blefo rt hemajorit y  o f deve lo pe rs a s o pp osedto H a ske ll.

As  little c ode in d ep en dencies  as possible:  W e aim at h av ing  minim u m  client- side dependencies. That ’ s why w e c hoseforexample P rea ct ins tea d  of Re act. B ig de pe nde n c ies w i t hlot sof unusedf e atu res m ak e re asoning  about the overall saf ety of the co dehard e r  s inc e  t h eyar e n’t a s easily review able and t he y  v astly incr e ase  t he atta ck surf ace.We aimat having  minimumcl ient - s ide  dependenc ies. Tha t’s why w e  chos e  f or ex amp le Pre ac t i nstea d of R e act . Big  depen de ncieswithlo ts of un used features make reas oningabout  th e overall  sa f ety  of the c odeharder sin cethe y are n’t as ea sily re vie w ableandt hey vastl y  i ncr e a se  the attack s u rfa ce. S tat e lessne ss:We don’t use loca l  storage at al l, e x c ept  fo r  tri vi al things like  wh et h e r you wa nt  to display  the dis cl a imerthe ne xt tim e you o p e nt he pag e or  no t, but we  de fi n itely d ono t  store  any th ing re latedt o yo u r  wallet. Our wal let i s a lig h t w allet  s o inste a d of  storing a nd syncingthe bl ockc hainlocally ,we fet chal l the data we need f rom t he bloc kc hain  ex plorer  — a p ublic ly a va ila ble and s y n ce d  c op y  of  the  bloc kc hain .

We don ’ t use lo cal storage  a t a l l , exce p tf o r trivialthi ngs l i k e whethery ou w a nt to di splay
 hardware_wallet integration_and the Ledger Nano_one is_on_the way_but_this probably won’t_be ready anytime_soon (50% progress at_the time of_writing_this blog) and it certainly wasn’t in January 2018, when we began the research_and_development of_CardanoLite.

Another_sad_fact is that Daedalus has_to store and sync the_whole blockchain_in order to work and this is really_time_and disk space_consuming.

But as we don’t like to complain in vain,_we decided to address those issues_by coming up_with_our_own cardano light wallet_implementation. Lacking a precise enough Cardano_technical specification, we resorted to reverse-engineering_Daedalus’s backend from the Cardano codebase made_mostly in Haskell.

Achieving Security

Those are the_principles we are following to_make our_light wallet as safe as_possible:

Make the project_publicly auditable_and easy to_review: The source code is available_on GitHub, you_can review it, build it yourself_locally_and compare the_resulting_bundle_with the_one actually hosted_on_the site._The_most relevant part of the code_is_around two thousand lines of ES6 JavaScript,_which is a lot_less_than the official cardano_implementation of Daedalus and it’s_certainly more readable for the majority_of developers_as opposed_to Haskell.

As little code in dependencies as possible: We aim at_having minimum client-side dependencies. That’s why_we chose for example_Preact instead_of_React. Big dependencies_with_lots of_unused features make reasoning about the overall_safety of_the code harder since they aren’t_as easily reviewable and_they_vastly increase the attack surface.

We aim_at having minimum client-side dependencies. That’s_why we chose for example_Preact_instead_of React. Big dependencies with_lots of unused features make reasoning_about the overall_safety of the code harder since they_aren’t_as easily reviewable and they vastly_increase_the attack surface. Statelessness: We don’t_use_local_storage at all, except for_trivial things like whether you want_to display the disclaimer the next time you open_the page or_not, but we definitely do_not_store_anything related to your wallet. Our wallet is a light_wallet so_instead of storing_and syncing the blockchain locally, we fetch all the data_we need from the blockchain explorer —_a publicly available and synced copy of the blockchain.

We don’t use_local storage at all, except for trivial things_like whether you want to display