02-Create-And-Derive-Keys.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div></div><div></div><div><strong>Installed Packages</strong><ul><li><span>CardanoSharp.Wallet, 2.14.0</span></li></ul></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#r \"nuget:CardanoSharp.Wallet,2.14.0\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create and Derive Keys\n",
    "\n",
    "Once you have your Mnemonic generated or restored, we want to turn it into keys. This will help us generate addresses and sign transactions. \n",
    "\n",
    "In this section we will cover:\n",
    " - Methods to Derive Keys\n",
    " - Type of Purposes\n",
    " - Key Pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods to Derive Keys\n",
    "\n",
    "There are 3 different ways to derive keys: \n",
    " - String\n",
    " - WalletPath\n",
    " - FluentApi\n",
    "\n",
    "These are methods are specific to this library and all result in the same keys being derived."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "using CardanoSharp.Wallet;\n",
    "using CardanoSharp.Wallet.Models.Keys;\n",
    "using CardanoSharp.Wallet.Models.Derivations;\n",
    "\n",
    "// We need a mnemonic to work with\n",
    "IMnemonicService mnemonicService = new MnemonicService();\n",
    "Mnemonic mnemonic = mnemonicService.Generate(24);\n",
    "\n",
    "// We will use this for String and WalletPath\n",
    "PrivateKey rootKey = mnemonic.GetRootKey();\n",
    "\n",
    "// we will use this for FluentApi\n",
    "MasterNodeDerivation rootNode = mnemonic.GetMasterNode();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deriving Keys via String\n",
    "\n",
    "This method requires knowledge of the Address Derivation paths. You will need to understand notation for Hardened and Soft Derivation. You will also need to know the different steps in the derivation path.\n",
    "\n",
    "If you would like to learn more about this subject please refer to the Cardano Developer Portal: https://developers.cardano.org/docs/get-started/technical-concepts/#key-derivation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Payment Private Key: 787ad23c74f53250a494ee4a6b6334adc36285ea26067cc39e9a6305bfcefb486d2e4fcf5cbc3c11a3a5da32f16f0595a17fdd5a7eb9d86559baf07f711022ff\r\n",
      "Payment Public Key: 71327d8ff6f13024b1937354ad7f37ca186b846da75b209c8bb6bf7386fa5048\r\n",
      "Payment Chaincode: b58df6b2ba62bbaa8821723ef79a56a07424722f5fc69c3a654b01f2ec13d69d\r\n",
      "Stake Private Key: e09367bb9fc741592955608bf6fbc0ea78d6727f6a352c14e74d9a61c3cefb480b1a718d2266a4620cd18ce2d31a60654ff5f257521e1e2a883b887ccf779a33\r\n",
      "Stake Public Key: 27b658c41093aeb3f7dbbeba4b2160e3b5aa691f6e893d3c852847c424d00c8d\r\n",
      "Stake Chaincode: 9eb9aa8c0319dac7476d1dbdc5e4789381286f8bc79fd2d38e712311b0a04287\r\n"
     ]
    }
   ],
   "source": [
    "using CardanoSharp.Wallet.Extensions;\n",
    "using CardanoSharp.Wallet.Models.Keys;\n",
    "using CardanoSharp.Wallet.Extensions.Models;\n",
    "\n",
    "// This path will give us our Payment Key on index 0\n",
    "// Note this is also a Shelley style wallet, denoted by the 1852'\n",
    "string paymentPath = $\"m/1852'/1815'/0'/0/0\";\n",
    "\n",
    "// The paymentPrv is Private Key of the specified path.\n",
    "PrivateKey paymentPrv = rootKey.Derive(paymentPath);\n",
    "// Get the Public Key from the Private Key\n",
    "PublicKey paymentPub = paymentPrv.GetPublicKey(false);\n",
    "Console.WriteLine($\"Payment Private Key: {paymentPrv.Key.ToStringHex()}\");\n",
    "Console.WriteLine($\"Payment Public Key: {paymentPub.Key.ToStringHex()}\");\n",
    "Console.WriteLine($\"Payment Chaincode: {paymentPrv.Chaincode.ToStringHex()}\");\n",
    "\n",
    "// This path will give us our Stake Key on index 0\n",
    "string stakePath = $\"m/1852'/1815'/0'/2/0\";\n",
    "// The stakePrv is Private Key of the specified path\n",
    "PrivateKey stakePrv = rootKey.Derive(stakePath);\n",
    "// Get the Public Key from the Stake Private Key\n",
    "PublicKey stakePub = stakePrv.GetPublicKey(false);\n",
    "Console.WriteLine($\"Stake Private Key: {stakePrv.Key.ToStringHex()}\");\n",
    "Console.WriteLine($\"Stake Public Key: {stakePub.Key.ToStringHex()}\");\n",
    "Console.WriteLine($\"Stake Chaincode: {stakePrv.Chaincode.ToStringHex()}\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deriving Keys via WalletPath\n",
    "\n",
    "`WalletPath` is really good for working with the different parts of the derivation path. You can break out and make decision based on the different pieces.\n",
    "\n",
    "First we will create a `WalletPath` using a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Path Purpose: Shelley\r\n",
      "Path Coin Type: Ada\r\n",
      "Path Account Index: 0\r\n",
      "Path Role Type: ExternalChain\r\n",
      "Path Address Index: 0\r\n",
      "Path Is Valid: True\r\n",
      "Path Is Full: True\r\n",
      "Path Is Partial: False\r\n",
      "Path Is Root: False\r\n",
      "Path Master Node: m\r\n",
      "Path Raw: m/1852'/1815'/0'/0/0\r\n"
     ]
    }
   ],
   "source": [
    "using CardanoSharp.Wallet.Models;\n",
    "\n",
    "// were going to utilize the above `paymentPath`\n",
    "// This represents a full path\n",
    "var walletPath = new WalletPath(paymentPath);\n",
    "Console.WriteLine($\"Path Purpose: {walletPath.Purpose}\");\n",
    "Console.WriteLine($\"Path Coin Type: {walletPath.Coin}\");\n",
    "Console.WriteLine($\"Path Account Index: {walletPath.AccountIndex}\");\n",
    "Console.WriteLine($\"Path Role Type: {walletPath.Role}\");\n",
    "Console.WriteLine($\"Path Address Index: {walletPath.Index}\");\n",
    "Console.WriteLine($\"Path Is Valid: {walletPath.IsValid}\");\n",
    "Console.WriteLine($\"Path Is Full: {walletPath.IsFull}\");\n",
    "Console.WriteLine($\"Path Is Partial: {walletPath.IsPartial}\");\n",
    "Console.WriteLine($\"Path Is Root: {walletPath.IsRoot}\");\n",
    "Console.WriteLine($\"Path Master Node: {walletPath.MasterNode}\");\n",
    "Console.WriteLine($\"Path Raw: {walletPath.ToString()}\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create `WalletPath` with Parts\n",
    "\n",
    "This time instead of using a string, we will pass the parts we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Path Purpose: Shelley\r\n",
      "Path Coin Type: Ada\r\n",
      "Path Account Index: 0\r\n",
      "Path Role Type: ExternalChain\r\n",
      "Path Address Index: 0\r\n",
      "Path Is Valid: True\r\n",
      "Path Is Full: True\r\n",
      "Path Is Partial: False\r\n",
      "Path Is Root: False\r\n",
      "Path Master Node: m\r\n",
      "Path Raw: m/1852'/1815'/0'/0/0\r\n"
     ]
    }
   ],
   "source": [
    "using CardanoSharp.Wallet.Enums;\n",
    "\n",
    "PurposeType purpose = PurposeType.Shelley;\n",
    "CoinType coin = CoinType.Ada;\n",
    "int accountIndex = 0;\n",
    "RoleType role = RoleType.ExternalChain; \n",
    "int addressIndex = 0;\n",
    "\n",
    "var walletPathParts = new WalletPath(\n",
    "    purpose,\n",
    "    coin,\n",
    "    accountIndex,\n",
    "    role,\n",
    "    addressIndex\n",
    ");\n",
    "Console.WriteLine($\"Path Purpose: {walletPathParts.Purpose}\");\n",
    "Console.WriteLine($\"Path Coin Type: {walletPathParts.Coin}\");\n",
    "Console.WriteLine($\"Path Account Index: {walletPathParts.AccountIndex}\");\n",
    "Console.WriteLine($\"Path Role Type: {walletPathParts.Role}\");\n",
    "Console.WriteLine($\"Path Address Index: {walletPathParts.Index}\");\n",
    "Console.WriteLine($\"Path Is Valid: {walletPathParts.IsValid}\");\n",
    "Console.WriteLine($\"Path Is Full: {walletPathParts.IsFull}\");\n",
    "Console.WriteLine($\"Path Is Partial: {walletPathParts.IsPartial}\");\n",
    "Console.WriteLine($\"Path Is Root: {walletPathParts.IsRoot}\");\n",
    "Console.WriteLine($\"Path Master Node: {walletPathParts.MasterNode}\");\n",
    "Console.WriteLine($\"Path Raw: {walletPathParts.ToString()}\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deriving Keys via FluentApi\n",
    "\n",
    "FluentApi is probably the easiest way to derive keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Payment Private Key: 787ad23c74f53250a494ee4a6b6334adc36285ea26067cc39e9a6305bfcefb486d2e4fcf5cbc3c11a3a5da32f16f0595a17fdd5a7eb9d86559baf07f711022ff\r\n",
      "Payment Public Key: 71327d8ff6f13024b1937354ad7f37ca186b846da75b209c8bb6bf7386fa5048\r\n",
      "Payment Chaincode: b58df6b2ba62bbaa8821723ef79a56a07424722f5fc69c3a654b01f2ec13d69d\r\n"
     ]
    }
   ],
   "source": [
    "IIndexNodeDerivation paymentNode = rootNode\n",
    "    .Derive(PurposeType.Shelley)\n",
    "    .Derive(CoinType.Ada)\n",
    "    .Derive(0) //Account Index\n",
    "    .Derive(RoleType.ExternalChain)\n",
    "    .Derive(0); //Address Index\n",
    "\n",
    "//By default, we only derive the private key\n",
    "//   this function will generate our public key\n",
    "paymentNode.SetPublicKey();\n",
    "Console.WriteLine($\"Payment Private Key: {paymentNode.PrivateKey.Key.ToStringHex()}\");\n",
    "Console.WriteLine($\"Payment Public Key: {paymentNode.PublicKey.Key.ToStringHex()}\");\n",
    "Console.WriteLine($\"Payment Chaincode: {paymentNode.PrivateKey.Chaincode.ToStringHex()}\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Purpose Types\n",
    "\n",
    "CardanoSharp supports CIP1852 (Shelley), CIP1854 (MultiSig), and CIP1855 (Policy Keys). Using `WalletPath` or FluentApi, you can easily derive these different types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "// WalletPath\n",
    "var shelleyWalletPath = new WalletPath($\"m/{(int)PurposeType.Shelley}'/1815'/0'\");\n",
    "var multiSigWalletPath = new WalletPath($\"m/{(int)PurposeType.MultiSig}'/1815'/0'\");\n",
    "var policyKeysWalletPath = new WalletPath($\"m/{(int)PurposeType.PolicyKeys}'/1815'/0'\");\n",
    "\n",
    "// FluentApi\n",
    "IAccountNodeDerivation shelleyFluent = rootNode\n",
    "    .Derive(PurposeType.Shelley)\n",
    "    .Derive(CoinType.Ada)\n",
    "    .Derive(0);\n",
    "\n",
    "IAccountNodeDerivation multiSigFluent = rootNode\n",
    "    .Derive(PurposeType.MultiSig)\n",
    "    .Derive(CoinType.Ada)\n",
    "    .Derive(0);\n",
    "\n",
    "IAccountNodeDerivation policyKeysFluent = rootNode\n",
    "    .Derive(PurposeType.PolicyKeys)\n",
    "    .Derive(CoinType.Ada)\n",
    "    .Derive(0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate a Key Pair\n",
    "\n",
    "All of our examples have used the Hierarchical Deterministic (BIP39) method for getting key pairs. You also can just generate a single key pair. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [],
   "source": [
    "using CardanoSharp.Wallet.Models.Keys;\n",
    "using CardanoSharp.Wallet.Extensions;\n",
    "using CardanoSharp.Wallet.Extensions.Models;\n",
    "\n",
    "KeyPair keyPair = KeyPair.GenerateKeyPair();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like HD Key Pairs, you can sign and verify."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "vscode": {
     "languageId": "dotnet-interactive.csharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Message String: 'CardanoSharp is awesome!'\r\n",
      "Message Hex: 'cabdb79c1ac912b0c0fc96d1'\r\n",
      "Message Signature: '844a208228b2ea759160f304d121521204ffd1d5cfa1c4e68b3f6ffc5f53c0682c76f600dbf2d642c25ebfd994e6f7334d8dac4514805853e3993ec4f79b440a'\r\n",
      "Can we verify? 'Yes'\r\n"
     ]
    }
   ],
   "source": [
    "// A simple message to sign\n",
    "string message = \"CardanoSharp is awesome!\";\n",
    "// Convert message to a byte[]\n",
    "byte[] messageByte = message.HexToByteArray();\n",
    "Console.WriteLine($\"Message String: '{message}'\");\n",
    "Console.WriteLine($\"Message Hex: '{messageByte.ToStringHex()}'\");\n",
    "\n",
    "// Sign the message with our KeyPair's Private Key\n",
    "byte[] signature = keyPair.PrivateKey.Sign(messageByte);\n",
    "Console.WriteLine($\"Message Signature: '{signature.ToStringHex()}'\");\n",
    "\n",
    "// Using the KeyPair's PublicKey, we can verify the Signature \n",
    "bool verified = keyPair.PublicKey.Verify(messageByte, signature);\n",
    "Console.WriteLine($\"Can we verify? '{(verified ? \"Yes\" : \"No\")}'\");"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "file_extension": ".cs",
   "mimetype": "text/x-csharp",
   "name": "C#",
   "pygments_lexer": "csharp",
   "version": "9.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}