Crytpnox is developing and producing hardware wallets (cold storage) in smart card format
In this article, we will explain how to use a specific version (B-NFT-1)of the card as a blockchain door lock opener. This card type was specifically designed for NFT. The principle is to provide door access to the owner of an NFT assigned to the door lock. Upon on-chain confirmation of NFT ownership of the NFT by the key on the card, the device unlocks. This project can deployed either on a Rapsberry Pi or an ESP32. Libraries are available for both.

We are using an Ethereum Virtual Machine compatible blockchain with ERC1155 smart contract. A door lock checks token balance of wallet address in cryptnox card for access.

The code of the project is published on the following repository:

GitHub - Cryptnox-IOT-Projects/Blockchain-Door-Lock-Access: Using a Cryptnox Card for door access linked to the temporary ownership of an NFT in a smart contract. The device will check ownership of an NFT associated with a Cryptnox hardware wallet card and authorize access if owned

Base hardware requirements:

• A Cryptnox NFT SmartCard (Type B-NFT-1). You can purchase a Cryptnox SmartCard or on the Cryptnox Shop
• A smart card reader
• A solenoid door lock
• A 12V power supply
• A relay module
• Jumper wires

Raspberry Pi setup hardware requirements:

• A Raspberry Pi Model 4

ESP32 setup hardware requirements:

• Esp32-WROOM-32
• Adafruit PN532 Breakout Board
• Logic level converter
• Buck converter ( XL6009E1 or LM2596 )
• 10uf capacitor

Software required:

• Cryptnox NFT Card Manager. Can be downloaded here:
  https://github.com/Cryptnox-Software/Cryptnox-NFT-Manager/releases

Core functionality of the use case is as follows:

1. A Cryptnox NFT card is initialized and seeded.
2. The user uses the card with wallet connect via Cryptnox NFT Manager and rents token from the smart contract via a website: there is an example of such a Web3 website based on the code of our repository HERE.
3. Use the card to open door lock

Functionality of the door lock setup is as follows:

1. Reader picks up card inserted/tapped
2. Checks wallet address on card if corresponding token exists
3. If Yes, door lock opens. Otherwise, door lock stays closed.

Part 1: Preparing the door lock setup with:

Raspberry PI

Jumper wires connect as follows:

Rasp Pi to Relay

• Power (red) from PIN(2) of Rasp Pi to “IN” of relay.
• Communication (blue) from PIN(12) of Rasp Pi to “VCC” of relay.
• Ground (black) from PIN(6) of Rasp Pi to “GND” of relay.

Relay to 12V power supply and solenoid door lock

• Power (red) from 12V power supply to Solenoid door lock.
• Communication (blue) from relay(COM) to solenoid door lock.
• Ground (GND) from relay(NO) to 12V power supply.

ESP 32 & Arduino Mega 2560

Esp32 to PN532 breakout board ( SPI interface )

• Esp32 ( g16 ) connects to PN532 ( SCL )
• Esp32 ( g23 ) connects to PN532 ( SDA , MOSI )
• Esp32 ( g19 ) connects to PN532 ( MISO )
• Esp32 ( g18 ) connects to PN532 ( SCK )
• 3.3V connects to 3.3V
• GND connects to GND

Connection of Esp32 , Logic Level Converter and 12V Relay

• Esp32 ( GND ) connects to Relay ( GND )
• Esp32 ( 3.3V ) connects to Logic Level Converter ( LV )
• Esp32 ( g32 ) connects to Logic Level Converter ( TX1 )
• Logic Level Converter ( TX0 ) connects to Relay ( IN )

Connection of 12V power adapter, 12V Relay and Solenoid Door lock

• Power adapter ( VCC ) connects to Relay ( COM )
• Power adapter ( VCC ) connects to 12V Relay ( VCC )
• Power adapter ( GND ) connects to Solenoid door lock ( GND )
• Relay ( NO ) connects to Solenoid door lock ( VCC )

Connection of 12V power adapter, XL6009E1 buck converter and Esp32

• Power adapter ( VCC ) connects to XL6009E1 ( IN ( + ) )
• Power adapter ( GND ) connects to XL6009E1 ( IN ( — ) )
• XL6009E1 ( OUT ( + ) ) connects to Esp32 ( 5V, Vin )
• XL6009E1 ( OUT ( — ) ) connects to Esp32 ( GND )

This one is to step down the 12V to 5V dc for Esp32 because it’s not recommended to power the Esp32 with 12V. Adjust the knob on the buck converter to reduce dc 12V to 5V. Now the whole project can run with 12V. You can also use other buck converters like LM2596.

Connection of 10uF Capacitor to Esp32 ( Optional )

• Capacitor positive pin ( anode ) to Esp32 ( EN )
• Capacitor negative pin ( cathode ) to Esp32 ( GND )

This connection is optional for auto boot. If you set up this connection, you don’t need to press the boot when uploading the program on Esp32.

And you can solder the capacitor directly to Esp32 like this if you don’t want to connect it with jumper wire.

Part 2: Initialize and seed a Cryptnox B-NFT-1 Card

Use Cryptnox NFT Card Manager.

Start application -> Scan card -> Initialize card and follow instructions.

Part 3: Rent door lock token from ERC1155 smart contract via frontend

You must setup a Web3 website such as THIS (look in repo for corresponding code).

In the “Connect wallet” options, choose “Wallet Connect”.
Click on “copy link”.

In the Cryptnox NFT Manager, choose the wallet connect tab,
paste the previously copied link then connect. Confirm signing to connect successfully.

Once the wallet is connected to the site, rent your desired token. The rent fee will be 0.001 Geth and the token has an expiry timer of 30 mins.

Part 4: Access door lock

With the setup completed, tap/insert your card on/into the reader, and observe as the door lock opens as it confirms the corresponding token exists in your wallet address.

If in case the token has expired (rented over 30 mins) , the door lock will stay closed and the token will be burnt from your address.

Demo Videos below:

Raspberry Pi Setup

ESP32 Setup

In this article, we will show how to materialize this NFT on a Cryptnox NFT card:

It was minted on the NFT marketplace Opensea using the store smart contract on Polygon chain (ERC1155).

The corresponding page looks like this (you can look at it here) :

Part 1:

Copy the URL of the display page of the NFT as above. In our case it will be:
https://opensea.io/assets/matic/0x2953399124f0cbb46d2cbacd8a89cf0599974963/37347503350343378463437055310135262586323054585479189953288949993764785488871

Part 2:

Download and install Cryptnox NFT Manager here (Only on Microsoft Windows for now).

Start it, and paste the above copied URL in the URL field, and press the Get fields button.

The app display will look like:

Part 3:

Put a Cryptnox NFT Card in a card reader (only one reader and one card), and press the Execute load button. Wait for 2–3 seconds as the car generates an internal random key pair, and then you will get the following display:

Look at the following field:

Your card address:
0x36dfe1bE81402512AD77f1D4753edb61796352f7

This is the public key of the on-card generated key pair !

Part 4:

Now we go back to the above NFT Opensea marketplace page, and we will transfer the NFT to the address of the card. Press the Transfer button on the upper right, and put the card address as recipient:

Validate with your Web3 wallet (It can perfectly be a Cryptnox Hardware Wallet Card, using Walletconnect). Then the transfer should be completed:

And now that the NFT is transferred to the address of the card, it is materialized on a Cryptnox NFT Card !

Chek on the NFT Manager app and press the Card info button. This appears:

As you can see, the Checking owner contract field = OK (it was not the case when the card was loaded, before performing the transfer).

Let’s get a bit more technical for a sec, so that you can grasp the technical materialization aspect. Look at the following data:

“No history entries”

This means that the private key was never used, thus no digital signature was ever performed with the private key generated on the card. Who ever is holding the card is 100% sure to be the sole owner of the card ! This cannot be completed with any other kind of hardware wallet as of this date !

Want to perform the above check on your phone ? Want to stream the NFT to your Apple TV ? Download the Cryptnox Wallet app from the Apple Store:

Start the App, scan the Crpytnox NFT Card and the corresponding menu will appear. Enjoy !!

Crytpnox is a swiss company developing and producing hardware wallets (cold storage) in smart card format.
In this project, we will show how a Cryptnox Hardware wallet smart card can be used to secure the private key for a token minting power meter. It can potentially have an application to projects related to tokenized Kilowatts per hour (kWh) of renewable origin. The solution presented can also have application to any kind of sensor readings.

We are using an Ethereum Virtual Machine compatible blockchain with ERC20 smart contract. The amount of kWh token minted by the device is equivalent to the measurement of kWh production over a period T.

The code of the project is published on the following repository:

GitHub - Cryptnox-IOT-Projects/kWh-Minting-Burning-Meter: Software & Hardware to create a Kilowatts per Hour Meter that mints (production) or burns (consumption) a corresponding kWh token

The hardware required:

• A Cryptnox Hardware Wallet Card (Type BG-1 ). You can purchase a Cryptnox Hardware Wallet SmartCard on Amazon or on the Cryptnox Shop
• A contact smart card reader (shop.cryptnox.com/pages/mini-smartcard-reader)
• A Raspberry Pi Model 3 or 4 with Ubuntu 22.04 installed
• A standard electricity power meter with SO pulse out connectors (standard IEC 62053–31). In our project, we will use a Velleman EMDINO1 rail mount kWh Meter (https://www.velleman.eu/products/view/?country=fr&lang=fr&id=411264)

The device will record electricity production from the SO pulse out reading of the meter.

The device’s core functionality is the following:

1. Measure electricity production on a connected wire in kWh over a period of time T
2. At the end of each period of time T, the device will perform the following actions:
   a) internally reads the total amount of kWh,
   b) generate a corresponding “mint” transaction for equivalent tokens of a specific smart contract,
   c) perform a digital signature with the Cryptnox Card,
   d) broadcast the signed transaction to the chain endpoint,
   e) reset the internal kWh reading to zero

Part 1: Connecting The Meter pulse out connectors to the Raspberry Pi

The meter will be connected to pins 2 and 40 of the Pi (pin description below)

The Pi 5v output (pin 2) is connected to the pulse out input connector of the Meter (connector 21). The pulse out output connector of the Meter (connector 20) is connected to a 10 K Ohm resistor, and then to pin 40 (GPIO 21) of the Pi (Note: to avoid “floating” and false pulse detection, it is mandatory to activate the internal pull down resistor on GPIO 40. This has been implemented in our code).

The meter will output an idle low voltage output (T_low), and on each pulse, a 90 ms high voltage output (see diagram below).

The Meter pulse out output will be connected to pin. Each pulse will be recorded by a python script.

In our case, the setup looks like that:

Part 2: Initialize a Cryptnox Hardware Wallet Card

You can either use CryptnoxPro command line software from Cryptnox, or you can use an Iphone (more user friendly):

Download Cryptnox Wallet from the Apple store:

‎Cryptnox Wallet

Start application -> scan card -> Initialize card and follow instructions.

Save the public address on Icloud for easy recovery for later.

Part 3: deploy the contract KWHContract.sol to the EVM compatible chain of your choice (We used Rinkeby testnet).

1. Go to `https://remix.ethereum.org`, create a new workspace
2. Under contracts, rename file as desired, paste code from solidity file from repository into renamed file on remix:
   https://github.com/Cryptnox-IOT-Projects/kWh-Minting-Burning-Meter/tree/main/energyERC20contract/remix
3. Compile and Deploy
4. In Deployed Contract, find the addMinter function, paste the public address of the Cryptnox Hardware Wallet card and press “Transact”

Part 4: Install and update the Python script on the Raspberry Pi

Install the script from the repository as per the Readme file, and update contract address in line 29 of pulse_monitor.py

Part 5: Start the electricity production and minting process

You can use consumption from the grid for simulation. Execute the script in the console to start the measuring and minting loop.

Dont forget the arg arguments to the python pulse_monitor.py command, <wallet_public_address> <gpio_number>

The console should look like that when it mints tokens:

On etherscan, the minting transaction should appear: