updated details | STRATIS | The first blockchain developed for businesses |Full POS

  • Stratis CEO Discusses Big News and their upcoming ICO Platform

    Stratis announces a large company that is about to launch an ICO on the Stratis platform...

    Get an inside look at the CEO of one of the most forward thinking blockchain solutions out there,

  • Stratis ICO Platform Full Release

    Today we are pleased to announce the release of the Stratis ICO Platform. The ICO Platform is feature rich and enables users to deploy an ICO within minutes via the ‘Deploy to Azure’ button.

    Features of the Stratis ICO Platform include:

    • A highly customizable design, which enables you to ensure the ICO site conforms with your unique branding.

    • The ability to accept funds in USD, BTC, STRAT and 50+ additional cryptocurrencies via Changelly, a service that enables ICO contributors to pay in many digital currencies.

    • Integration with Onfido’s ‘Know-Your-Customer’ (KYC) service that screens contributors against anti-money laundering watch-lists and undertakes document checks.

    • Support for Hierarchical Deterministic (HD) wallets, enabling issuers to collect funds securely. This means the funds collected during the ICO are not stored on the server itself.

    • The Stratis ICO Platform is provided free of charge, overcoming the high costs of existing crowd-funding solutions.

    Chris Trew, CEO of Stratis, commented: “With this platform we’ve drastically improved the user experience for both ICO issuers and contributors. Today’s ICO solutions tend to be either DIY, which comes with substantial security risks or they tend to charge a significant fee, but it doesn’t need to be this way. At Stratis, we are focused on making blockchain simple and accessible, which is why the core Stratis blockchain has been written completely from the ground up in the widely understood language of C# and the .NET framework. We want as many developers as possible to access the benefits of decentralised technology.”

    The Stratis ICO Platform and associated documentation is now available on GitHub: https://github.com/stratisproject/ICO-Platform

  • Stratis Smart Contracts in C# Alpha Release

    Stratis are proud to announce the alpha release of Stratis Smart Contracts in C#.

    A significant amount of time and effort has gone into developing a new approach to Smart Contracts, ensuring the product is easy to learn and the most inclusive platform for developers and businesses.

    Stratis has engineered the first smart contracts platform built entirely from the ground up in native C# on the .NET framework, the most popular enterprise programming language on the most widely-used enterprise framework.

    This makes it easier to integrate into existing enterprise architectures than other platforms, Stratis Smart Contracts in C# opens many doors previously blocked due to computing language barriers. Stratis will soon also provide support for the functional programming language F#, particularly popular in the finance sector.

    “We believe smart contracts are one of the backbones of blockchain as a transparent, decentralized marketplace, and that the more inviting you can be to get people to join that marketplace, the faster blockchain will be adopted” says Stratis CEO Chris Trew. “Our foundation in C# and .NET programming broadens the world of smart contracts immediately, and we look forward to seeing what people do with it.”

    Several other blockchain companies have launched smart contracts offerings, but required development in an entirely different programming language or a new digital ecosystem with new languages, decompilers and integrated development environments (IDEs). Stratis Smart Contracts in C# builds upon an established and popularized framework, language and ecosystem. Therefore, it is more readily poised for wider adoption as a smart contract standard.

    Below is a technical overview of the Stratis Smart Contract in C# offering at the recent Blockchain Expo, London.

    “Stratis believes blockchain will change the world, and we are creating products that make this new world as inclusive and welcoming as possible,” Trew says. “Stratis Smart Contracts in C# is designed to welcome developers.”

    To get started with Stratis Smart Contracts in C#, please refer to the below materials.

    Documentation: https://smartcontractsdocs.stratisplatform.com Faucet: https://smartcontractsfaucet.stratisplatform.com/ GitHub Repository: https://github.com/stratisproject/StratisBitcoinFullNode/tree/sc-alpha Discord (Smart Contracts Support): https://discord.gg/3AA8PYm

  • Stratis Release Interim Wallet v2.0.0.4



  • Stratis Sidechains Alpha Release

    Stratis are proud to announce the Stratis Federated Sidechains Alpha Release in C# on the .NET framework.

    Stratis has focused on developing the sidechains infrastructure to ensure the product is easy to use and the most inclusive platform for developers and enterprises.

    Enterprises can create their own sidechains whilst benefiting from on-going enhancements to the Stratis blockchain. Stratis Sidechains provide enterprises with the ability to provision custom sidechains with flexible modules such as consensus, block size and privacy; delivering scalable blockchain solutions.

    Building sidechains in C# makes it easier to integrate into existing enterprise architectures and opens the door previously blocked due to programming language barriers. Stratis sidechains in C# builds upon the established .NET framework, language and ecosystem. Therefore, it is more readily poised for wider adoption.

    Stratis CEO Chris Trew states, “Sidechains provide a means to quickly provision, sandbox and deploy a bespoke blockchain tailored to specific enterprise processes. Because Stratis sidechains remain linked to the well-established Stratis mainchain, enterprises can be certain their blockchain implementations will continue to benefit from enhancements made by our core team of highly-experienced developers.”

    Sidechains improve scalability of blockchains, a long-running challenge of decentralised computing. Aside from leaving the mainchain free to exchange funds, Stratis sidechains make it possible to specify both the block size and block interval, increasing the number of transactions in each block and/or reducing the time between each block.

    Sidechain wallets will allow cross-chain transactions for users to transfer funds between the Stratis mainchain and the sidechains. This interoperability feature enables interactions across blockchains while giving users the confidence that any sidechain’s digital assets will always be backed by the Stratis token.

    Stratis is also working on enabling enterprises to run smart contracts on their respective sidechains which will be implemented in a future release.

    To showcase this technology, we have created a test environment named Apex on the Stratis testnet network. The Apex sidechain interacts seamlessly with the STRAT mainchain on the testnet network. Users can easily participate in testing this technology themselves by exchanging TSTRAT for TAPEX coins.

    You can now try out the Stratis Sidechains Alpha Release by setting up Stratis and Apex wallets on the testnet network and use them for cross-chain deposits and withdrawals.

  • Stratis Q1/Q2 Development Roadmap Update

    Stratis is pleased to share a summary of development milestones based
    on the Q1/Q2 2018 roadmap. This update highlights the key releases
    delivered by Stratis in the first half of 2018.

    Full Node The release of the Full Node mainnet beta was a significant milestone for Stratis. Enhancements were made across core components such as the P2P code and consensus protocol.

    Release Date: 28th March 2018

    Stratis Core (Full Node GUI) Stratis Core was successfully released on mainnet, improving user experience and functionality. This release also included an updated instance of the Stratis Full Node.

    Release Date: 11th April 2018

    ICO Platform The Stratis ICO Platform was made available and is easily deployable on Microsoft Azure. This platform is feature-rich, including support for HD Wallet and integrated KYC support.

    Release Date: 9th May 2018

    Breeze Wallet with Privacy Protocol Stratis is aware of the excitement around the Breeze with Privacy Protocol release and appreciates the continued patience. Work is progressing on the project and further updates will be communicated in due course.

    Release Date: To be confirmed.

    Stratis Academy The Stratis Academy allows developers to gain an in-depth knowledge of blockchain technology utilizing the Stratis Platform. This release was well received by the development community and we will be carrying out regular updates to the content.

    Release Date: 28th June 2018

    Stratis Identity Stratis has added additional features to the Identity iOS App and have resubmitted the application to Apple for App Store approval. Stratis Identity is readily available for Android on the Google Play Store.

    Release Date: To be confirmed.

    Stratis Smart Contracts C# developers can now start building their own smart contracts in native C# and deploy them on the Stratis blockchain. This alpha release is the first smart contracts platform built entirely from the ground up in native C# on the .NET framework.

    Stratis has designed an example that developers can follow on the Stratis Academy.

    Release date: 16th May 2018

    Stratis Sidechains The Stratis Sidechains alpha release unlocked the possibilities of scaling the Stratis blockchain using sidechains. This was achieved using a Two-Way Federated Peg solution that enables cross-chain transactions to and from a sidechain.

    Release Date: 27th June 2018

    Chris Trew stated “Our Q1/Q2 2018 development roadmap was intentionally aggressive in terms of what we wanted to achieve. I’m proud of what the team has delivered, with the introduction of important updates to the Stratis Platform. The ability to run smart contracts and to provision sidechains opens up a world of potential applications that enterprises can build on the Stratis Platform. I look forward to seeing the creative innovations third-party developers will realise.”

    Stratis is looking forward to the second half of 2018 and will be publishing the Q3/Q4 roadmap in the coming weeks.

  • Stratis Identity iOS Release + How to install the Stratis Identify app for iOS?

    Today, we are proud to release the free Stratis Identity app for Apple iOS devices. Built on top of the Stratis platform, this showcases personal and corporate identity management capabilities on the Stratis blockchain. The Stratis Identity app delivers a real use case for users to attest their identity on an immutable ledger and share that data with others.

    Stratis CEO Chris Trew explains, “Mass adoption of blockchain will only come through simplicity, and Stratis Identity offers a streamlined way to verify one’s identity through popular social media accounts, using pre-existing Microsoft, LinkedIn or Google account information. Once one’s true identity is established through our app, a Stratis Identity can be shared securely without ever exposing any specific user’s sensitive personal data.

    Stratis Identity app creates a permanent, unique record of a person or organization’s identity on the Stratis blockchain and provides permission-only access to that identification. Each online social media profile has information linked to it (username, e-mail, job title, etc.) stored by the account provider.

    Key features of the Stratis Identity app include:

    • Creation of a unique Stratis Blockchain identity, registered and secured on the Stratis blockchain
    • Attest your identity by logging into a selection of social media accounts such as Microsoft, Google and LinkedIn
    • Proof of ownership of online accounts via sharing your unique public addresses and transaction hashes
    • Validate other people’s Stratis Identities using the built-in verification tool

    The free Stratis Identity app is available for iOS devices using the download link below:


    How to install the Stratis Identify app for iOS?

    1. Navigate to the Stratis Identity iOS app download link using your iOS device

    2. Click Install

    3. Go to home screen to check progress

    4. A dialog will appear prompting you to trust Stratis Group Ltd.

    5. Open “Settings” and go to “General -> Device Management”

    6. Choose to trust “Stratis Group Ltd”

    7. Your Stratis Identity iOS app is ready for use now and enjoy!

  • The ‘Stratis Puzzle’ Challenge

    Stratis is seeking the ‘best of the best’ with a series of 12 sequential puzzles, each more challenging than the last. Each task tests general logic, blockchain knowledge, cryptography and aptitude with the Stratis Platform itself.

    Chris Trew, Stratis CEO added: “Finding talented blockchain developers is notoriously difficult as demand far outweighs supply. The puzzle is our way of connecting with new talent, but equally the winner might choose to walk away with the cash prize, and that’s absolutely fine too.

    The top prize, equivalent to over $10,000, will remain locked in a wallet controlled by the private key that is recovered after solving all 12 of the Puzzle’s tasks. Each task reveals a single word from the mnemonic phrase that provides access to the wallet holding the prize fund.

    There are also two development roles up for grabs on the Stratis core team with an automatic job offer made to the first contestant that solves at least 10 of the 12 tasks.

    Krushang Patel, Stratis CMO commented: “If you think you have what it takes to mix it with the best in the community, then we encourage you to try the Stratis Puzzle. We have two genuine roles on offer as part of our core team, and the puzzle was the most logical and entertaining way we could think to fill them.

    Anyone that wants to give the puzzle a try should begin with the first task. Once contestants have solved the first puzzle, which requires no blockchain knowledge, the next step will be revealed.

    The prize fund can be viewed on the Stratis blockchain explorer here

    Stratis Puzzle, first task:

    This is the first of the 12 tasks that make up the Stratis puzzle, an additional step will be revealed once this below task is completed.

    7b22515220636f6465203231783231223a7b22766572746963616c223a5b5b372c322c312c37 5d2c5b312c312c312c312c312c315d2c5b312c332c312c312c312c312c312c332c315d2c5b31 2c332c312c312c312c312c332c315d2c5b312c332c312c342c312c332c315d2c5b312c312c31 2c315d2c5b372c312c312c312c375d2c5b335d2c5b342c312c312c312c322c223342222c315d 2c5b312c322c322c312c312c315d2c5b322c322c312c325d2c5b322c223241222c312c312c31 2c325d2c5b312c342c322c312c325d2c5b322c332c315d2c5b372c312c315d2c5b312c312c32 2c322c312c223143225d2c5b312c332c312c312c312c312c345d2c5b312c332c312c322c342c 335d2c5b312c332c312c322c335d2c5b312c312c312c352c223144225d2c5b372c312c312c33 2c315d5d2c22686f72697a6f6e74616c223a5b5b372c322c375d2c5b312c312c312c312c312c 312c315d2c5b312c332c312c312c312c312c332c315d2c5b312c332c312c322c312c312c332c 315d2c5b312c332c312c312c322c312c332c315d2c5b312c312c312c312c315d2c5b372c312c 312c312c375d2c5b312c315d2c5b312c332c312c312c312c345d2c5b322c312c312c352c345d 2c5b312c312c342c223241222c312c325d2c5b322c312c325d2c5b332c312c322c332c355d2c 5b312c312c312c345d2c5b372c322c322c325d2c5b312c312c312c312c315d2c5b312c332c31 2c322c332c315d2c5b312c332c312c312c322c325d2c5b312c332c312c223142222c332c315d 2c5b312c312c322c325d2c5b372c342c223143222c223144225d5d7d7d

    Anyone interested in the Stratis Puzzle can join the Stratis #puzzle Discord channel
    for community discussion on the various tasks. Blockchain is a
    collaborative and open source environment, Stratis recognizes that
    people may collaborate

  • Breeze with Privacy Protocol Mainnet Release

    The Breeze Wallet with Breeze Privacy Protocol public Mainnet release is now available and represents a key step in our product development roadmap. The Breeze Wallet showcases our technology with a strong emphasis on privacy and security on the blockchain network. This primarily serves organizations that want to obfuscate business to business transactions securely on the blockchain.

    This version of the Breeze Wallet includes the Breeze Privacy Protocol feature as well as a user-friendly interface.  It also features the Masternode Client Discovery protocol where the blockchain is used to discover, validate, and connect to a Stratis Masternode, which provides the privacy protocol service. This discovery process is undertaken in a decentralized and trustless manner that is resistant to network disruption.

    This is a Mainnet release and is now open to the public. Enhancements made to both the Breeze Wallet user interface and the Masternode Client Discovery Protocol have been incorporated into this release.

    For more information about how the Breeze Masternode registration protocols works, please visit this technical blog post: https://stratisplatform.com/2017/10/30/masternode_registration_protocol/

    Download the Breeze Wallet with Breeze Privacy Protocol for Mainnet from the link below. The wallet will then automatically discover and connect to an available Mainnet Stratis Masternode.


    Download for Windows 64-bit https://github.com/BreezeHub/BreezeProject/releases/download/v1.0.0/Breeze.Wallet-v1.0.0-setup-win-x64.exe

    Download for Windows 32-bit https://github.com/BreezeHub/BreezeProject/releases/download/v1.0.0/Breeze.Wallet-v1.0.0-setup-win-ia32.exe

    Download for Mac OS X https://github.com/BreezeHub/BreezeProject/releases/download/v1.0.0/Breeze.Wallet-v1.0.0-mac.dmg

    Download for Ubuntu https://github.com/BreezeHub/BreezeProject/releases/download/v1.0.0/Breeze.Wallet-v1.0.0-linux-amd64.deb

    User Guides

    Download for Breeze Wallet User Guide


    Download for Stratis MasterNode User Guide


  • Stratis (STRAT) Release Wallet v2.0.0.5

    Source Code:


  • Stratis Update BitcoinFullNode (sc-alpha-latest)

    sc-alpha-latest: [SC] Update SC nodes to handle value transfers (#1909)

    * Use same Network in NodeGroupBuilder when creating nodes (#1843)
    * -agentprefix displays as entered. (#1894)
    Somewhere along the way -agentprefix stopped working. 
    This fixes.
    * Clean up TransactionBuilderContext to be easier for a user to use. (#1889)
    * - Moved Revipient to its own class
    - Removed unused CoinType object
    * Removed unused Network from WalletTransactionHandler
    * In TransactionBuildContext, moved most of the ctor parameters out.
    * Made InitializeTransactionBuilder protected
    * Removed Transaction from the TransactionBuildContext
    * Removed Sign from the TransactionBuildContext
    * Version updates for SC v0.11.0-alpha (#1896)
    * Stratis.SmartContracts update
    * Remove SCT launch args
    * Update client version
    * Parameters fix
    * [SC] Fix ordering of fluent API in SC-daemon so mempool loads on startup (#1902)
    * Stratis.SmartContracts update
    * Remove SCT launch args
    * Update client version
    * Parameters fix
    * Move mempool to after consensus so node can load with mempool
    * [SC] Add IContract abstraction (#1901)
    * Increase lastpowblock (#1904)
    * [SC] Consending txs use Time of 'parent' transaction (#1906)
    * Use Time of 'parent' transaction
    * Remove DateTimeProvider

    Source Code:


  • Stratis ICO Platform available on the Microsoft Azure Marketplace

    Stratis is happy to announce that the ICO Platform is now listed and available for deployment via the Azure Marketplace, making it the first Blockchain-Based Web App solution available on the Marketplace.

    Chris Trew stated “Utilizing the Stratis ICO Platform on Azure allows ICO Administrators to leverage the advantages of Azure’s PaaS offerings. Removing the headaches with typical standalone virtual machine deployments that are all too common. Our solution tied with Microsoft Azure allows an ICO Administrator to ensure their data is safe and their ICO is always available.”

    Following the May release of The Stratis ICO Platform, which allows an ICO to be deployed in minutes, we have implemented a number of enhancements.

    Firstly, the Stratis ICO Platform now allows the issuer to screen out participants by geography. By integrating functionality from IP Stack, the ICO platform now identifies an ICO participant’s geography by their IP address, with a screening list to limit the use of VPNs and TOR. This enhancement is an important step for ICO issuers that wish to avoid contributions from a particular geography for regulatory or legal reasons. It is now straightforward to screen out contributions from the US, for example. This update further enhances the utility of the Stratis ICO Platform, making it even easier to run a compliant ICO.

    The Stratis ICO Platform utilises Hierarchical Deterministic Wallets. This provides added security for issuers as funds collected during the ICO are not stored on a server. As part of today’s announced enhancements, the Stratis Breeze Wallet now includes additional features required to display ICO contributions that breach the address gap-limit. This update means issuers using the Breeze Wallet with its new ‘Advanced Tab’ can very reliably and simply retrieve their ExtPubKey, generate addresses and resynchronize to a given date.

    The Stratis ICO Platform is now available via the Azure Marketplace:

    If you’re interested in running an ICO and are in need of some consultancy, do not hesitate to contact us via email at [email protected]

  • Stratis Partners with UK Meds

    ratis is pleased to announce our latest partnership with the UK’s fastest growing online pharmacy, UK Meds.

    UK Meds is the fastest growing online pharmacy in the UK, digitally handling between 3,000 and 4,000 patient prescriptions each day. The company will deploy Stratis’ blockchain technology to improve patient safety across the online pharmacy sector as a whole, reducing instances of patients ordering multiple prescriptions.

    By ensuring each patient’s request for a prescription is logged on a shared and immutable distributed ledger across a group of UK online pharmacies, the programme ensures patients can only access prescribed quantities of medication. Doctors dealing with online consultations and pharmacies preparing medication will have the ability to cross reference patients using a unique identifier assigned to each individual. Any previous request for medication across all online pharmacies in the programme will be easily referenceable using Stratis’ technology, ensuring patients receive correct prescriptions.

    Joe Soiza, CEO at UK Meds commented:

    Despite screening our own customers by IP addresses, phone numbers, cookies and many other factors, there isn’t a cross-industry solution to identify patients attempting to obtain multiple orders of drugs, with opioids being a particular example. Clearly our entire industry needs to come together to ensure we do everything possible to protect the vulnerable and utilizing Stratis’ technology can help us achieve that.
    The Stratis Platform provides a highly secure blockchain solution that can be shared across the industry to provide a trusted and verifiable record of patient requests for medicine. We are initiating this programme, and we have over 10 online pharmacies onboard already. It’s our ambition for this to become the de facto standard across the entire UK industry.

    Stratis’ technology will also be used to improve UK Meds’ own supply-chain by deploying Stratis’ Smart Contracts in C#, this is essentially code running on top of a blockchain enabling them to undertake specific tasks, at critical stages. In combination with track and trace logistics solutions, each shipment of medication will be logged on the blockchain when originally produced by the manufacturer, during points of distribution and again on arrival at UK Meds to certify pharmaceutical shipments are correctly packed, arrive in fine condition and remain securely sealed in the correct quantity.

    Chris Trew, CEO at Stratis added:

    This is a great example of blockchain being deployed where its unique qualities will make a real difference. Using traditional IT solutions to solve this issue would require a significant expense and would undoubtedly be administered by a third-party organization. With blockchain, the industry can cooperate on the critical issue of patient safety using a shared version of the truth.

  • Stratis Q4 Development Roadmap

    The Stratis Q4 Development Roadmap is now publicly available and provides an overview of the key deliverables to come from Stratis heading into the new year. Much of this work begun during Q3 of this year and the end of 2018 will see Stratis deliver a number of our core product offerings that will set us up for further customer engagement moving into 2019. 

    Stratis Full Node Production Release

    The Stratis Full Node will be delivered as a production ready release. This will allow Stratis to embark on moving to a full C# Mainnet network.

    Stratis Sidechains Production Release

    Stratis Sidechains will be deployable on Stratis Mainnet allowing companies to create their own customized sidechains off the Stratis mainchain.

    Smart Contracts in C# Production Release

    The release of Stratis Smart Contracts in C# is scheduled for Q4 of this year. This will allow the development and deployment of Smart Contracts in C# onto Stratis sidechains.

    Stratis ICO Platform V2

    New features are being integrated into the Stratis ICO Platform. These features are based on feedback received from organisations utilising our ICO platform and also enhancements scheduled as part of our ongoing product development.

    Stratis Cold Staking

    The implementation of Stratis Cold Staking as part of the roadmap will enable Stratis holders to stake their balance in a cold-wallet. The activation of this technology is subject to the adoption of the Stratis Full Node.

    Stratis DLT

    Distributed Ledger Technology (DLT) is a requirement for the large majority of private institutions. Stratis has been diligently developing a C# DLT solution to fit the needs of organizations looking to utilize blockchain technology within a private environment.

    Stratis Core

    Stratis Core will be updated with the production ready instance of the Stratis Full Node. This will be our wallet to replace the existing StratisX (QT) staking wallet.


    The Breeze Wallet will be updated with additional features and will utilize the production ready instance of the Stratis Full Node.

    Stratis Academy

    There is a focus on creating even more content on the Stratis Academy allowing developers and organizations to gain a deeper understanding of how they can build on top of the Stratis Platform. In addition, the Stratis Academy user interface will have a new look and feel.

    Breeze Privacy Protocol for STRAT

    Following the successful release of the Breeze Privacy Protocol for Bitcoin we will also be delivering the same functionality for STRAT. This will enable users to increase their anonymity when interacting with the Stratis token.

  • The Breeze Wallet Is Adding A New Level Of Privacy To BTC! Learn How STRAT Is Making This Possible

    Stratis Group Ltd has just released the mainnet beta of the Breeze Wallet, a decentralized, in-wallet privacy solution for Bitcoin. It is an implementation of TumbleBit, a privacy protocol which uses a trustless tumbler that cannot steal BTC and cannot undermine the anonymity of the parties involved.

    The Breeze Wallet uses a Stratis Masternode server to provide users with a very high anonymity set (and, therefore, privacy with regards to their activity) and to make BTC fungible.

    A later version of the Breeze Wallet may also provide a robust scaling solution for Bitcoin itself. In building the Breeze Wallet, Stratis have made a resounding commitment to improving the cryptocurrency space. This article aims to throw some light on how all of this is achieved.

    Read full article here:

  • Stratis Puzzle Solutions

    On July 25, 2018, Stratis released their ‘Puzzle Challenge’. The Puzzle is solved and Stratis gave away 4.000 $STRAT and two job offerings.

    On behalf of the Puzzle makers ‘Aprogiena and NoEscape0’, I would like to thank everyone for the participation in the Stratis Puzzle. They hope you had a fun time solving it.


    Congratulations to the winners:

    • Main price: 4000 STRAT, team of: - Luigy - JTobcat - lotek - mattm - ziot
    • Second price: Job offer — someguy
    • Third prize: Job offer — MithrilMan


    Since the puzzle is finished ‘Aprogiena and NoEscape0’ would like to share solutions for all pieces of the puzzle.

    Puzzle 1 — Nonogram

    Original assignment:



    Which is hex that results in:

    {"QR code 21x21":{"vertical":[[7,2,1,7],[1,1,1,1,1,1],[1,3,1,1,1,1,1,3,1],[1,3,1,1,1,1,3,1],[1,3,1,4,1,3,1],[1,1,1,1],[7,1,1,1,7],[3],[4,1,1,1,2,"3B",1],[1,2,2,1,1,1],[2,2,1,2],[2,"2A",1,1,1,2],[1,4,2,1,2],[2,3,1],[7,1,1],[1,1,2,2,1,"1C"],[1,3,1,1,1,1,4],[1,3,1,2,4,3],[1,3,1,2,3],[1,1,1,5,"1D"],[7,1,1,3,1]],"horizontal":[[7,2,7],[1,1,1,1,1,1,1],[1,3,1,1,1,1,3,1],[1,3,1,2,1,1,3,1],[1,3,1,1,2,1,3,1],[1,1,1,1,1],[7,1,1,1,7],[1,1],[1,3,1,1,1,4],[2,1,1,5,4],[1,1,4,"2A",1,2],[2,1,2],[3,1,2,3,5],[1,1,1,4],[7,2,2,2],[1,1,1,1,1],[1,3,1,2,3,1],[1,3,1,1,2,2],[1,3,1,"1B",3,1],[1,1,2,2],[7,4,"1C","1D"]]}}

    This encodes nonogram. The correct visualization is:

    Those numbers represent series of black squares in one row or column. The whole idea is similar to sudoku puzzle. 1D, 3B and so on — those are hints to decrease amount of possible solutions so it’s easier for the solver, they specify exact coordinates where the black squares should be and therefore eliminating guessing their position.

    And the solution is:

    This QR leads to a link shortener (http://bit.ly/2GIbl2H) which will redirect you to https://github.com/Aprogiena/StratisBitcoinFullNode/blob/experiment/hrpuzz/hrpuzz/readme.md which contains introduction and also gives the first word which is market. Then you were supposed to go to the words directory and open market.txt.

    Puzzle 2 — hash of the next word

    Original assignment:



    If you google it you find out that it’s a hash of the word perfect.

    Puzzle 3 — tx hash

    Original assignment:



    This is a hash of the transaction. If we look it up in the chain explorer we will find it: https://chainz.cryptoid.info/strat/tx.dws?e241a9203ce4fd5a31677a9bd293f34453c58304a6222d8b957533717c21dfe2.htm

    There is an output with a script ”OP_DUP OP_HASH160 636f6e74696e7565207769746820227365656422 OP_EQUALVERIFY OP_CHECKSIG” inside this transaction.

    636f6e74696e7565207769746820227365656422is hex which can be converted to the following string: continue with “seed”. So the next word is seed.

    Puzzle 4 — logs

    Original assignment:

    To find the next word, you need to download Stratis full node code 
    from this GitHub repository branch: https://github.com/Aprogiena/StratisBitcoinFullNode/tree/experiment/hrpuzz
    Then you need to build the solution and set up trace logs for “Stratis.Bitcoin.Features.Consensus.*”. 
    Then run the node on Stratis testnet and inspect the corresponding log file once the node is fully synced with the network.
    Hint: Read https://github.com/stratisproject/StratisBitcoinFullNode/blob/master/Documentation/using-logging.md on how to enable trace level logging.


    In order to enable the logs NLog.config file should be created with single logging target: Stratis.Bitcoin.Features.Consensus.*. Then we need to sync and investigate the logs.

    NLog.config file should look like the following one:

    <?xml version="1.0" encoding="utf-8" ?>
    <nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" autoReload="true">
        <target name="debugConsensusFile" xsi:type="AsyncWrapper" queueLimit="10000" overflowAction="Block" batchSize="1000">
          <target xsi:type="File" fileName="consensus.txt" archiveNumbering="Date" maxArchiveFiles="14" archiveEvery="Day" layout="[${longdate:universalTime=true} ${threadid}${mdlc:item=id}] ${level:uppercase=true}: ${callsite} ${message}" encoding="utf-8" />
        <logger name="Stratis.Bitcoin.Features.Consensus.*" minlevel="Trace" writeTo="debugConsensusFile" />    

    Logs would contain the following:

    Puzzle 5 — faucet

    Original assignment:

    For the next word, you will again need to work with Stratis full node. This time, however, you need to implement a new feature.
    More specifically, you need to implement understanding of new payloads to your node. 
    Let's call these payloads FaucetRequest, FaucetChallenge, FaucetSolution, FaucetReward.
    Your node needs to connect to a special node on testnet that listens on this IP address:
    After a standard handshake, your node can send FaucetRequest payload (network command "faucetreq"), which contains:
    – your Stratis testnet address (40 bytes long byte array that encodes the address as an ASCII string with 0 bytes padding at the end)
    The special node replies with FaucetChallenge (network command "faucetchal"), which contains:
    – SHA256 hash (32 bytes long byte array)
    – challenge data (28 bytes long byte array)
    To which your node is supposed to reply with FaucetSolution (network command "faucetsol") payload, which contains:
    – challenge data (28 bytes long byte array, byte copy from FaucetChallenge)
    – nonce (4 bytes long byte array) such that SHA256 (challenge data + nonce) = hash from FaucetChallenge, where + operator is concatenation of byte arrays
    The nonce can be interpreted as 32-bit unsigned integer written in network byte order. As such it is guaranteed that the value stored in the integer is lower than 0x01000000.
    If the solution is correct, the special node replies with FaucetReward (network command "faucetrew"), which contains:
    – the next word (8 bytes long byte array that encodes the word as a string with 0 bytes padding at the end)
    Moreover, the special node will send you some coins to the address you specified in FaucetRequest.
    If at any point, you violate the protocol, your node may be disconnected.
    Example of the protocol:
    1) After a handshake, your node sends FaucetRequest:
    54 46 45 37 52 32 46 53 41 67 41 65 4A 78 74 31
    66 67 57 32 59 56 43 68 39 5A 63 34 34 38 66 33
    6D 73 00 00 00 00 00 00
    which would represent testnet address TFE7R2FSAgAeJxt1fgW2YVCh9Zc448f3ms.
    2) The special node replies with the following FaucetChallenge:
    25 71 9b 0b e9 d9 96 36 05 0b 2e f9 25 eb de 54
    f7 2b 9d 3d 83 ce 2d de fb 28 f0 69 27 4d 33 9e 
    12 34 56 78 90 AB CD EF 11 22 33 44 55 66 77 88
    99 00 AA BB CC DD EE FF 11 12 22 33 
    The first 32 bytes would represent the hash 25719b0be9d99636050b2ef925ebde54f72b9d3d83ce2ddefb28f069274d339e
    and the remaining 28 bytes would represent the challenge data. 
    3) Then your node is expected to send the following FauceSolution back:
    12 34 56 78 90 AB CD EF 11 22 33 44 55 66 77 88
    99 00 AA BB CC DD EE FF 11 12 22 33 00 00 FA DE
    where the nonce would be 0x0000FADE.
    4) If the solution is correct, the special node replies with FaucetReward:
    6C 61 6C 61 6C 61 00 00
    which would represent the the next word is "lalala".


    In order to solve this puzzle we need to first construct a payload class:

    public class FaucetChallengePayload : Payload
        public byte[] Hash;
        public byte[] ChallengeData;
        public FaucetChallengePayload()
            this.ChallengeData = new byte[28];
            this.Hash = new byte[32];
        public FaucetChallengePayload(FaucetChallenge challenge)
            this.ChallengeData = challenge.ChallengeData;
            this.Hash = challenge.Hash;
        public override void ReadWriteCore(BitcoinStream stream)
            stream.ReadWrite(ref this.Hash, 0, 32);
            stream.ReadWrite(ref this.ChallengeData, 0, 28);

    And then the solution payload:

    public class FaucetSolutionPayload : Payload
        public byte[] ChallengeData;
        public byte[] Nonce;
        public FaucetSolutionPayload()
            this.ChallengeData = new byte[28];
            this.Nonce = new byte[4];
        public FaucetSolutionPayload(byte[] challengeData, byte[] nonce)
            Guard.Assert(challengeData.Length == 28);
            Guard.Assert(nonce.Length == 4);
            this.ChallengeData = challengeData;
            this.Nonce = nonce;
        public override void ReadWriteCore(BitcoinStream stream)
            stream.ReadWrite(ref this.ChallengeData, 0, 28);
            stream.ReadWrite(ref this.Nonce, 0, 4);

    When we receive the challenge we need to solve it and send the solution back to the server.

    Solution can be created like this:

    public static byte[] SolveChallenge(byte[] hash, byte[] challengeData)
        Guard.Assert(hash.Length == 32);
        Guard.Assert(challengeData.Length == 28);
        uint nonce = MinNonce;
        while (nonce < MaxNonce)
            byte[] nonceBytes = nonce.ToBytes();
            List<byte> challengeWithNonce = challengeData.ToList();
            var hashOutBytes = Hashes.SHA256(challengeWithNonce.ToArray());
            if (StructuralComparisons.StructuralEqualityComparer.Equals(hashOutBytes, hash))
        return nonce.ToBytes();

    When the server responds with a reward payload we need to parse it. Here is the reward payload:

    public class FaucetRewardPayload : Payload
        public string Word
                string result = System.Text.Encoding.UTF8.GetString(this.bytes.Substring(0, this.bytes.ToList().IndexOf(0x0)));
                return result;
        private byte[] bytes;
        public FaucetRewardPayload()
            this.bytes = new byte[8];
        public FaucetRewardPayload(string word)
            List<byte> bytes = word.ToBytes().ToList();
            while (bytes.Count < 8)
            this.bytes = bytes.ToArray();
        public override void ReadWriteCore(BitcoinStream stream)
            stream.ReadWrite(ref this.bytes, 0, 8);

    The reward would contain word basket.

    Also we would receive a transaction of value 1.24326789 STRAT.

    Puzzle 6 — broken test

    Original assignment:

    We are still working with the Stratis full node code here (from GitHub repository branch 
    The project contains many tests. One of the tests inside Stratis.Bitcoin.Features.MemoryPool.Tests 
    project fails. Can you help us fixing it?
    Once you fix the test properly, you can calculate an ID of the transaction that this test creates. 
    Take the ID and XOR it with
    to reveal the next word.


    Failing test looks like this:

    public async Task AcceptToMemoryPool_WithMinimalOutputAmountPossible_IsSuccessfullAsync()
        string dataDir = Path.Combine("TestData", nameof(MempoolValidatorTest), nameof(this.AcceptToMemoryPool_WithMinimalOutputAmountPossible_IsSuccessfullAsync));
        var minerSecret = new BitcoinSecret(new Key(Encoding.UTF8.GetBytes("00000000000000000000000000000012")), Network.Main);
        ITestChainContext context = await TestChainFactory.CreateAsync(Network.Main, minerSecret.PubKey.Hash.ScriptPubKey, dataDir);
        IMempoolValidator validator = context.MempoolValidator;
        var destSecret = new BitcoinSecret(new Key(Encoding.UTF8.GetBytes("00000000000000000000000000000034")), Network.Main);
        var tx = new Transaction();
        tx.AddInput(new TxIn(new OutPoint(context.SrcTxs[0].GetHash(), 0), PayToPubkeyHashTemplate.Instance.GenerateScriptPubKey(minerSecret.PubKey)));
        long fee = 100000;
        long minAmountPossible = 1;
        // spending the minimum amount possible
        tx.AddOutput(new TxOut(new Money(minAmountPossible), destSecret.PubKeyHash));
        // change
        tx.AddOutput(new TxOut(new Money(context.SrcTxs[0].TotalOut.Satoshi - fee - minAmountPossible), destSecret.PubKeyHash));
        tx.Sign(minerSecret, false);
        MempoolValidationState state = new MempoolValidationState(false);
        bool isSuccess = await validator.AcceptToMemoryPool(state, tx);
        Assert.True(isSuccess, "P2PKH tx not valid.");
        Directory.Delete(dataDir, true);

    Simply by iterating different fee numbers we can come up with the appropriateminAmountPossible value which is 546.

    Hash of the transaction is ac4c405f95320801f9244b13eaea5f676c55c22456ba2af48d3df460393030d7.

    Now if we xor 8c1b2533f9126c6e97416733a5b81d2e3875ab5776d44f8cf91d830f4b541ef7 with ac4c405f95320801f9244b13eaea5f676c55c22456ba2af48d3df460393030d7 and convert it to string we will get Well done, ORBIT is next word.

    Puzzle 7 — Script

    Original assignment:

    In order to produce new block on Stratis network, a miner has to be online with running node and have its wallet open. 
    This is necessary because at each time slot, the miner is supposed to check whether any of its UTXOs is eligible to 
    be used as so-called coinstake kernel input and if so, it needs to use the private key associated with this UTXO 
    in order to produce the coinstake transaction.
    A coinstake transaction in Stratis protocol is a special transaction that is at the second position in each block. 
    The UTXO that is spent in this transaction in its first input (called kernel) has to meet some special properties 
    in order to be allowed to be used as the kernel. 
    The chance of a UTXO to be eligible for producing a coinstake transaction grows linearly with the number of coins 
    that this UTXO presents.
    This implies that the biggest miners on the network are required to keep the coins in an open hot wallet. This is 
    dangerous in case the machine where the hot wallet runs is compromised.
    We propose cold staking, which is mechanism that eliminates the need to keep the coins in the hot wallet. With cold 
    staking implemented, the miner still needs to be online with running the node and open hot wallet, but the coins that 
    are used for staking, can be safely stored in a cold storage. Therefore the open hot wallet does not need to hold any 
    significant amount of coins, or it can even be empty.
    To implement cold staking, we use a soft fork to redefine OP_NOP10 instruction, newly renamed to 
    OP_CHECKCOLDSTAKEVERIFY. The new behaviour of this opcode is as follows:
     * Check if the transaction spending an output, which contains this instruction, is a coinstake transaction. 
       If it is not, the script fails.
     * Check that ScriptPubKeys of all inputs of this transaction are the same. If they are not, the script fails.
     * Check that ScriptPubKeys of all outputs of this transaction, except for the marker output (a special first output 
       of each coinstake transaction) and the pubkey output (an optional special second output that contains public key 
       in coinstake transaction), are the same as ScriptPubKeys of the inputs. If they are not, the script fails.
     * Check that the sum of values of all inputs is smaller or equal to the sum of values of all outputs. If this does 
       not hold, the script fails.
     * If the above-mentioned checks pass, the instruction does nothing.
    Using this new opcode, we can now construct a coinstake transaction output in a way that there are two keys that can 
    be used to spend the output. 
    The first key is the key from the hot wallet. We want this key to be usable only for creating another coinstake 
    transaction that preserves this limitation to the newly created output.
    The second key is the key from the cold storage. We want this key to be able to spend the output arbitrarily.
    Your task in this puzzle is to create a ScriptPubKey of an output of such a cold staking coinstake transaction that 
    utilizes the new opcode. The ScriptSig to spend that output for another cold staking transaction using a hot wallet 
    key is:
    <sig> <hotPubKey> 1
    The ScriptSig to spend that output arbitrarily using a cold storage key is:
    <sig> <coldPubKey> 0
    Write your ScriptPubKey on a single line with opcodes written with capital letters and instead of hot wallet public 
    key hash use <hotPubKeyHash> and instead of cold storage public key hash use <coldPubKeyHash>. Use a single space 
    as the separator. There is no new line character or separator at the end. Use the P2PKH template as an inspiration.
    Note that there are many ways on how to write the script, so let's agree on using OP_CHECKCOLDSTAKEVERIFY just 
    before OP_CHECKSIG. We are not looking for the shortest possible version of how to write the output to the chain, 
    which is prevented by the agreed specific position of OP_CHECKCOLDSTAKEVERIFY, but we make that condition in order 
    to eliminate many ways of writing the solution. Even with the condition, there are many ways left, but few make 
    good sense.
    For example, if you were about to construct P2PKH ScriptPubKey for the hot wallet key, you would write:
    And then you would calculate its SHA256 hash, which is 
    Once you are done, calculate SHA256 hash of your cold staking coinstake output ScriptPubKey. Then XOR the hash with 
    to reveal the next word.


    By trying different scripts which satisfy the requirement we will come up with the following script:


    If we hash it using SHA256 we will get: 128CA0C608CADAFE8B9BF450BD6A0EA6C098D51EC0D96E6E45D619DC33D420C2.

    Now we xor 128CA0C608CADAFE8B9BF450BD6A0EA6C098D51EC0D96E6E45D619DC33D420C2 with 32c1e59540ea97bbd8d3d41df83946868ddd8656e0942b3d0df65499609c00e` and get the following string:


    Puzzle 8 — hidden fork

    Original assignment:

    Once again you will need to work with the full node code from this GitHub repository branch:
    A secret faction of Stratis forked away from Stratis test net. Only one node is known to be operating on this secret network. 
    It operates on Your task is to infiltrate their network and sync with their chain.


    First we need to connect to that node by applying -connect= to the config or command line arguments.

    After doing that we would get the following in the console:

    info: Stratis.Bitcoin.Connection.ConnectionManagerBehavior[0]
          Peer '[::ffff:]:35353' offline, reason: 'A banned node tried to connect.'.

    It appears that the target node is banned. After investigation why we find out the source of the problem:

    this.BanPeer(new IPEndPoint(IPAddress.Parse("").EnsureIPv6(), 35353), 12345678, "Once you sync with their chain, find the block number 373052 and inspect it.");

    in PeerBanning.cs.

    If we remove this line we will now get a different connection error that we need to investigate. The node would send us RejectPayload with a message Your version is outdated! Use 90000.

    Now if we fake our version to be 90000 and connect we will be able to start syncing but only until the block 373050 and then we will get an error.

    To fix this error we need to remove a checkpoint:

    { 373050, new CheckpointInfo(new uint256("0x1347a27e3e52bd1a0b7bad7e9d8257c3e81793be911afe826f606bbcb4d2fff7"), new uint256("0xc9d7ed7835ec1fcea87031b3bb08d74d3bbdc97278a8ef402da3264070069b43")) },

    And only after that we will be able to sync till the block 373052 as mentioned in the hint we got in the step 2.

    Now we inspect this block and find out the following text in the coinbase transaction: Next is ‘glare’.

    Puzzle 9 — largest transaction

    Original assignment:

    What is the TXID of the largest (in terms of its size in bytes) TX on Stratis testnet before block 400000?
    Is it bdc206c4ef88ebe64b68c25fab307c55b3c0cc0725120d2a8356d73cce7f19af? No, it is not.


    We can check every transaction of each block after syncing enough blocks and then using BlockRepository.GetAsync to retrieve all the blocks one by one and then check every transaction in every block. For every transaction we need to calculate serialized size using Transaction.GetSerializedSize method.

    By checking all the transactions in every block before 400000 we find the biggest transaction: fcae6bab9cfccb92230db03a8b0a5575f4afec734a32694bed31b24ee00b61db.

    By XORing it with bdc206c4ef88ebe64b68c25fab307c55b3c0cc0725120d2a8356d73cce7f19af we receive the following text: Almost there :) Go to danger.txt

    Puzzle 10 — vanity address

    Original assignment:

    Next one is easy. Just generate a private key and public key pair, such that the mainnet Stratis 
    address representing the public key starts with "STRAT" (case-sensitive).
    Then connect to a special node on testnet that listens on this IP address: and after 
    a standard handshake send it VanityRequest payload and receive VanityResponse payload.
    VanityRequest (network command "vanityreq") is defined as:
    – compressed public key P, which address on Stratis mainnet starts with "STRAT" (33 bytes long byte array)
    - length L of signature (1 byte)
    - signature of SHA256d(P) created with the corresponding private key (L bytes long byte array)
    If the solution is correct, the special node replies with VanityResponse (network command "vanityres"), which contains:
    – the next word (8 bytes long byte array that encodes the word as a string with 0 bytes padding at the end)


    To solve this we need to generate a vanity address:

    public static void VanityKey()
        Network network = Network.StratisMain;
        int i = 0;
        var start = DateTime.Now;
        Parallel.For(0, int.MaxValue, new ParallelOptions { MaxDegreeOfParallelism = 16 }, (int iteration) =>
            var result = Interlocked.Increment(ref i);
            if (result % 50000 == 0)
                var triesPerSec = result / (DateTime.Now - start).TotalSeconds;
                Console.WriteLine("i: {0}  speed: {1}", result, triesPerSec);
            if (TryGeneratePrivKeyWhichAddrStartsWith("STRAT", network, out byte[] seed, out string addressStr))
                string byteStr = "";
                foreach (var b in seed)
                    byteStr += b.ToString() + " ";
                Console.WriteLine("FOUND IT: " + addressStr + " BYTES: " + byteStr);


    public class VanityRequestPayload : Payload
        public byte[] pubKeyBytes;
        public byte[] signatureBytes;
        public VanityRequestPayload()
            this.pubKeyBytes = new byte[33];
        public VanityRequestPayload(byte[] pubKeyBytesArray, byte[] signatureBytes)
            this.pubKeyBytes = pubKeyBytesArray;
            this.signatureBytes = signatureBytes;
        public override void ReadWriteCore(BitcoinStream stream)
            stream.ReadWrite(ref this.pubKeyBytes, 0, 33);
            byte signatureSize = 0;
            if (stream.Serializing)
                signatureSize = (byte)this.signatureBytes.Length;
            stream.ReadWrite(ref signatureSize);
            if (!stream.Serializing)
                this.signatureBytes = new byte[signatureSize];
            stream.ReadWrite(ref this.signatureBytes, 0, signatureSize);
        public static string GetAddrFromPubKey(byte[] pubKeyBytes)
            var pubkey = new PubKey(pubKeyBytes);
            BitcoinPubKeyAddress address = pubkey.GetAddress(Network.StratisMain);
            string addressStr = address.ToString();
            return addressStr;
    public class VanityResponsePayload : Payload
        public string Word
                string result = System.Text.Encoding.UTF8.GetString(this.bytes.Substring(0, this.bytes.ToList().IndexOf(0x0)));
                return result;
        private byte[] bytes;
        public VanityResponsePayload()
            this.bytes = new byte[8];
        public VanityResponsePayload(string word)
            List<byte> bytes = word.ToBytes().ToList();
            while (bytes.Count < 8)
            this.bytes = bytes.ToArray();
        public override void ReadWriteCore(BitcoinStream stream)
            stream.ReadWrite(ref this.bytes, 0, 8);

    Payload construction:

    var seedBytes = new byte[] { 62, 48, 83, 73, 57, 67, ...... };
    var key = new ExtKey(seedBytes);
    PubKey pubkey = GeneratePublicKey(key.Neuter().ToString(Network.StratisMain), 0, false);
    BitcoinPubKeyAddress address = pubkey.GetAddress(Network.StratisMain);
    var keyPath = new KeyPath("0/0");
    ExtKey privKey = key.Derive(keyPath);
    byte[] pubKeyBytes = pubkey.ToBytes();
    byte[] signatureBytes = this.Sign(privKey.PrivateKey, Hashes.Hash256(pubKeyBytes));
    var payload = new VanityRequestPayload(pubKeyBytes, signatureBytes);
    if (!address.ToString().StartsWith("STRAT"))
        throw new Exception("BAD PUBKEY BYTES");

    In that vanity response payload we will receive word able in case we generated and sent pubKey for a valid vanity address and the signature produced by the private key associated with that address.

    Puzzle 11 — mutated block

    Original assignment:

    To get the next word, exploit CVE-2012-2459 against a block number 333445 on the Stratis test net. 
    Once you create such a block, connect to a special node that is running on IP address
    and present that block using Block2 payload to the node after a normal handshake. 
    Block2 payload is exactly the same as Block payload, except for its network command, which is "block2".
    If the solution is correct, the special node replies with Phrase payload (network command "phrasere"), which contains:
    – instructions message (150 bytes long byte array that encodes next instructions as a string with 0 bytes padding at the end)


    Explanation of that vulnerability: https://bitcointalk.org/index.php?topic=102395.0

    Construction of the mutated block will look like this:

    var mutatedBlock = block333445.Clone(ProtocolVersion.PROTOCOL_VERSION, Network.StratisMain);
    var txToCopy1 = mutatedBlock.Transactions[mutatedBlock.Transactions.Count - 2];
    var txToCopy2 = mutatedBlock.Transactions[mutatedBlock.Transactions.Count - 1];
    mutatedBlock.Transactions.Add(txToCopy1.Clone(false, Network.StratisMain));
    mutatedBlock.Transactions.Add(txToCopy2.Clone(false, Network.StratisMain));
    if (mutatedBlock.GetHash() != block333445.GetHash())
        throw new Exception("Merkle root changed!");
    this.BlockMerkleRoot(mutatedBlock, out bool mutated);
    if (!mutated)
        throw new Exception("Not mutated");
    var payload = new MutatedBlockPayload(mutatedBlock);

    To a valid mutated block the server will answer with a payload that will contain:

    Next word is ‘engage’. Also note that the 7th word you received is actually word number 8, and 8th word you received is word number 7.

    Puzzle 12 — entropy

    Original assignment:

    Missing some entropy? Okay, here is some:


    After reading BIP39 and in general how HD wallets work we learn how mnemonic is generated.

    Here are the words from the previous puzzles:

    market perfect seed start basket orbit glare mesh danger able engage

    Their numbers in the worlds list:

    1089 1304 1559 1701 153 1247 790 1118 443 2 594

    And their binary representation is:


    To which we append provided entropy: 1110001

    And then make SHA256 of the whole entropy. First 4 bits from the result of the SHA256 is the missing checksum which is 1111 in binary.

    Now add the checksum to provided entropy to get: 11100011111, which is the index of the last word in binary, which is 1823 in decimal, which stands for the word token.

    Puzzle 13 — secret puzzle

    Original assignment:

    Congratulations! Now you can restore the wallet (you can use Swagger on the C# full node!), the password is value in satoshis (or stratoshis?) 
    you received from the faucet puzzle (1.23 STATS would translate to password "123000000"), account is "account 0".


    The password for the wallet is the amount in satoshis we received in faucet puzzle: 124326789.

    Wallets implementing BIP44 usually use gap limit of 20. Which would mean that the node would only see the prize if it would be deposited in the first 20 addresses. However we deposited the prize to address under index 1033. By manually deriving more addresses the node will be able to see the prize and spend it.

    Thanks for puzzling!



    Aprogiena, NoEscape0 and Khilone



  • Stratis - Microsoft Partnership

    Stratis is excited to announce that we are now a certified Microsoft Partner. Our mission is to get C# blockchain technologies in front of enterprise customers, and we look forward to utilizing the marketing and development resources Microsoft provides to its certified partners. The Azure Marketplace gives app and service providers access to 120,000 enterprise customers and 800,000 ecosystem partners in 190 countries. Microsoft actively helps to guide customers to their partners, and partners are given resources which allow them to increase their product’s exposure on Microsoft’s Go-To-Market Services.


    With over 1 million active users, the marketplace generates over 100,000 leads to partners every month – Microsoft ISV Program


    This partnership comes at a critical and also exciting time for Stratis; the services which constitute the core Stratis Platform, including smart contracts, sidechains, and the enterprise-focused Stratis DLT, are set to be released in the next few months. Stratis Group Ltd. are the first blockchain company with their own cryptocurrency to partner with Microsoft in this way, and this partnership will help us make the most of our unique position within Microsoft’s software environment. We also think of this step as just the first step in enhancing our existing relationship with Microsoft, and we aim to become a Gold Partner in the near future!


    This partnership gets me very excited indeed. I am looking forward to working with Microsoft’s Go-To-Market Team and further leveraging the Azure technology stack with the Stratis Platform. – Chris Trew


    The accreditation is indicative of the relationship that Stratis has with the .NET Framework, a software framework developed by Microsoft. Stratis is the first and only cryptocurrency with full nodes built from the ground up in C# meaning that applications built using the Stratis Platform are a part of the .NET ecosystem. This partnership is a natural next step for Stratis.

  • Stratis Full Node Production Release

    Stratis is proud to announce the production release of the Stratis C# Full Node on Mainnet.

    Stratis is proud to announce the production release of the Stratis C# Full Node on Mainnet. The Stratis Full Node uses the Microsoft .NET Core platform and is a C# port of Bitcoin Core. While StratisX nodes were limited to the Stratis blockchain network, the Stratis Full Node is capable of functioning as a peer on either the Stratis or Bitcoin network.

    The Stratis Full Node replaces StratisX as the engine powering the Stratis blockchain network. Stratis Smart Contracts in C# and Sidechains have been built on top of this new technology. Future advancements in the Stratis blockchain will also be built on this solid foundation, and therefore this production release marks a significant point on the Stratis roadmap.

    A future-proof and environmentally stable Proof-of-Stake algorithm drives Stratis nodes, and this release of the Full Node is suitable for staking STRAT on Mainnet. Cold staking is also included as part of this production release, and this feature will be activated when 95% of stakers have adopted this release.

    One of the aims when designing the Stratis Full Node was to make it component-based using a clean and customizable architecture. For example, Proof-of-Stake, Proof-of-Work, and Proof-of-Authority algorithms are all supported, and a Stratis Full Node can be set up to run with any of these. While a reference implementation is provided, this can easily be swapped out to work with an implementation that has been customized to work with a different database. At a more granular level, consensus rules can be added or removed as required.

    Including and excluding individual components to create a Full Node tailored to a specific purpose is simple, and the Stratis Full Node can also be easily extended to include custom features. Future developments will adhere to the existing philosophy and follow a modular design.

    As the Stratis Full Node has been built from the ground up in C# on the .NET Framework, Stratis has been able to incorporate optimizations. For example, when it comes to downloading the complete Stratis blockchain, the Stratis Full Node can do this significantly faster than a StratisX node, without compromising on security.

    Despite the innovations made when designing the Stratis Full Node, the Full Node still uses, out-of-the-box, a protocol that is very similar to the Bitcoin protocol, and therefore familiar to those who know Bitcoin.

    Migrating from StratisX to the Stratis Full Node is a straightforward process, and full documentation on how to do this is available here.

    The production release of the Stratis Full Node is immediately available from the official GitHub repository or can be seamlessly deployed to Azure via the Azure Marketplace.

  • Stratis Core Production Release

    Stratis Core is immediately available for download and installation from the wallets page.

    Stratis is pleased to announce the production release of the Stratis Core wallet, which comes with additional functionality and an improved user experience overall. This production release of Stratis Core runs with the latest version of the Stratis Full Node as the back end, which means this release is the most stable and secure so far.

    Several new features have been added to the Stratis Core wallet since the previous version, this includes but is not limited to.

    • Ability to Resync
    • Address Book Feature
    • Cold-Staking
    • ExtPubKey Retrieval
    • Large-Scale Address Generation
    • Node Statistics
    • Pagination

    For added security, Stratis Core also allows an optional passphrase to be used in conjunction with the mnemonic to generate your wallet’s private seed adding further security to your funds.

    Stratis Core is immediately available for download and installation from the wallets page.

    In addition, a guide has been put together to aid existing users of StratisX in migrating to Stratis Core, this guide can be viewed here.

  • Stratis Smart Contracts in C# and Stratis Sidechains Release

    This combination of two of our technologies forms an ideal pairing and marks the production release of both sidechains and smart contracts. As part of this release, Stratis has launched the Cirrus sidechain that supports smart contracts.

    Stratis is proud to announce the release of Stratis Sidechains and Smart Contracts in C#.

Log in to reply

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