Substrate reference.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LocalCoinSwap non-custodial Substrate integration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## __Prelude: Peer-to-peer (P2P) vs centralized exchanges__\n",
    "\n",
    "Readers will likely be immediately familiar with the lines and charts offered on a typical exchange. A typical exchange maintains an orderbook of *bids* and *asks*, and automatically executes trades by matching buyers and sellers whenever bidding and asking prices collide. Trading on typical exchanges focuses around high-speed execution, and price speculation. It is not uncommon to see additional derivative features on offer such as margin lending, or contracts-for-difference (CFD's) aimed at technical analysis day traders.\n",
    "\n",
    "```\n",
    "\"The root problem with conventional currency is all the trust required to make it work.\"\n",
    "- Satoshi nakomoto\n",
    "```\n",
    "\n",
    "Centralized exchanges are such named as they provide a central point in which local currency is aggregated. They maintain bank account which users wire funds to, and receive funds from. Although some are decentralized, most also aggregate the cryptocurrency of their users into company-owned wallets. Trading on a centralised exchange involves sending your funds to the exchange, and trusting that they will be kept safe on your behalf.\n",
    "\n",
    "Not surprisingly, centralised exchanges raise important questions as regards privacy and security, as well as the growing corporate monopolisation of a cultural space whose ethos centers around decentralization.\n",
    "\n",
    "Many have been the victim of hacking or large scale theft, and many users have had their local currency seized or frozen for various reasons ranging from accusations of criminality, to simple inability to provide sufficient documentation to satisfy regulatory agencies.\n",
    "\n",
    "Centralised exchanges also have stringent KYC requirements, which require users to send personal identity documentation to the exchange. In the past there have been leaks of this information - leaving users of the exchange susceptible to identity theft.\n",
    "\n",
    "A peer-to-peer exchange provides no central aggregation of local currency. In a style akin to eBay, traders on the exchange create advertisements (called offers) which indicate which cryptocurrency they wish to buy or sell. Other traders contact them, and the exchange acts only to safeguard the process of users trading with each other - by providing an escrow service for the cryptocurrency being traded.\n",
    "\n",
    "By decentralizing the local currency funds, the peer-to-peer exchange has no ability to seize the fiat currency of users. Most importantly however, a peer-to-peer exchange enables large-scale accessibility of cryptocurrency to mainstream users in a way impossible for a centralized exchange to match.\n",
    "\n",
    "The requirement of centralized exchanges to maintain bank accounts requires them to be heavily restrictive on which payment methods they can offer, and which locations they can accept users.\n",
    "\n",
    "A peer-to-peer exchange, on the other hand, can support trading using any traditional payment method, in any location of the world.\n",
    "\n",
    "Over the course of this document, I will demonstrate a way in which Substrate-based cryptos such as Polkadot and Kusama can be integrated on a peer-to-peer exchange, with no need for the end user to hand over their private keys.\n",
    "\n",
    "I will show the cryptography underlining the process in a proof-of-concept fashion, and back this document up with tests for each individual process.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import statements for document\n",
    "from scalecodec.metadata import MetadataDecoder\n",
    "from scalecodec import ScaleBytes\n",
    "\n",
    "import binascii\n",
    "import nest_asyncio\n",
    "from scalecodec.base import ScaleDecoder\n",
    "from substrateinterface.utils.hasher import blake2_256\n",
    "from substrateinterface.utils.ss58 import ss58_encode\n",
    "from substrateinterface.utils.ss58 import ss58_decode\n",
    "from substrateinterface import SubstrateInterface\n",
    "\n",
    "import settings\n",
    "from bindings import bip39\n",
    "from bindings import sr25519\n",
    "from bindings import multisig\n",
    "from ksmref import utils\n",
    "\n",
    "#Setup helper library\n",
    "substrate = SubstrateInterface(\n",
    "    url=settings.NODE_URL, address_type=2, type_registry_preset=\"kusama\")\n",
    "nest_asyncio.apply()\n",
    "raw_metadata = substrate.rpc_request(\"state_getMetadata\", None)['result']\n",
    "\n",
    "# print(raw_metadata)\n",
    "substrate.init_runtime(block_hash=None)\n",
    "genesis_hash = substrate.get_block_hash(0)\n",
    "#substrate.get_block_metadata(block_hash=None, decode=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: The signup process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a user signs up to LocalCoinSwap, a 24 word *mnemonic phrase* is generated in their browser. This mnemonic phrase is encrypted with the users password, and stored on our backend. We do not know the users passwords, as they are hashed prior to login, so we are also unable to decrypt the users mnemonic phrase.\n",
    "\n",
    "When a user logs in, the mnemonic phrase is sent to the browser and decrypted. It is then used as the basis for their wallet addresses, and the signing of transactions. This is similar to many popular web-based wallets.\n",
    "\n",
    "Users can export their mnemonic phrase, and thus recover funds contained on the associated addresses outside of the exchange.\n",
    "\n",
    "For the purposes of this generation, I have written bindings to the rust modules which handle BIP39 and the sr25519 algorithm. In production, this functionality will be handled more simply by the Polkadot JS keypair module on the frontend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raw seed from 24 word mnemonic:\n",
      "64c29cbfc0cec793d1c62a5d80261aa8a1c03535379cedbb0601c1f89ad2271e\n",
      "\n",
      "Public key:\n",
      "026cb1657e60212226cc8001b9c7eece72e58c5a218138ee93797a8ce38a1317\n",
      "\n",
      "Private key:\n",
      "dcfcd70c4095ac286c8c6390bece547b6724ff0569040ae7420bb30f9022e10bcd1fd45de0e527ef2a4ede9a7aeb28d7f90fcf0246d3ce0549939607d38f076a\n",
      "\n",
      "Kusama address:\n",
      "CdVuGwX71W4oRbXHsLuLQxNPns23rnSSiZwZPN4etWf6XYo\n"
     ]
    }
   ],
   "source": [
    "example_mnemonic = (\n",
    "    \"boy impose motor jump pear car\"\n",
    "    \" pet exact gravity section amazing marble\"\n",
    "    \" exit trim two doctor depart rose\"\n",
    "    \" guitar injury today stock fruit surface\"\n",
    ")\n",
    "\n",
    "seed_bytes = bip39.bip39_to_mini_secret(example_mnemonic, \"\")\n",
    "seed_hex = bytearray(seed_bytes).hex()\n",
    "\n",
    "keypair = sr25519.pair_from_seed(bytes.fromhex(seed_hex))\n",
    "\n",
    "public_key = keypair[0].hex()\n",
    "private_key = keypair[1].hex()\n",
    "address = ss58_encode(keypair[0], 2)\n",
    "\n",
    "print(f\"Raw seed from 24 word mnemonic:\\n{seed_hex}\")\n",
    "print(f\"\\nPublic key:\\n{public_key}\")\n",
    "print(f\"\\nPrivate key:\\n{private_key}\")\n",
    "print(f\"\\nKusama address:\\n{address}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Overview of the trade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A trade on LocalCoinSwap has 3 participants: the buyer, the seller, and the arbitrator.\n",
    "\n",
    "It's important at this point to distinguish also between the creator of the trade offer (the *maker*), and the responder to the trade offer (the *taker*). A seller can be a maker or a taker of a trade offer, as can the buyer.\n",
    "\n",
    "The most intuitive trade example involves the seller as the maker, and the buyer as the taker. The seller signs up to LocalCoinSwap, and then creates an offer which advertise their desire to sell crypto. The offer will specify terms and conditions of potential trades, such as the price, payment method, and location.\n",
    "\n",
    "The buyer also signs up to the platform, and responds to the sellers offer to create a *trade request*. Once the seller accepts the request, the trade begins.\n",
    "\n",
    "At this point a Substrate multisignature address is generated, using the addresses of the buyer, seller, and arbitrator. The seller prepares a transactions and places the funds in the multisignature escrow address.\n",
    "\n",
    "The buyer then pays the seller directly according to the conditions of the offer.\n",
    "\n",
    "After receiving payment, the seller then performs a special Substrate *approveAsMulti* transaction. This transaction specifies that they are giving permission for funds to travel from the escrow address to the buyer.\n",
    "\n",
    "As the address is multisignature, a second approval is required. The buyer has no crypto yet to create a second approval, so instead the arbitrator performs a Substrate *asMulti* transaction, giving the second lot of approval.\n",
    "\n",
    "At this point the funds move automatically from the escrow address to the buyer, and the trade is complete. Feedback will be exchanged, and both parties move on - the buyer in posession of the crypto, and the seller in posession of the local currency.\n",
    "\n",
    "Because the funds are in a multisignature address requiring 2/3 approval, and only the seller possesses his/her private keys, it is impossible for LocalCoinSwap to steal the funds from the users on the platform. It is also impossible for one party to defraud the other and escape with the cryptocurrency, because in a dispute the arbitrator can decide who receives the cryptocurrency.\n",
    "\n",
    "Following this abstract, I will demonstrate in full the blockchain functionality involved in conducting such a non-custodial trade.\n",
    "\n",
    "I will then cover all possible edge-case situations, such as disputes between the buyer and seller, or cancellation requests.\n",
    "\n",
    "Furthermore, I will demonstrate related cryptography required in the running of an exchange, such as gathering fee information, checking validity of published transactions, and dealing with error situations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 3: Starting a trade and generating the address"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we get the addresses of the trade participants, and then convert them to account ID's.\n",
    "\n",
    "We then perform an ascending numerical sort before using our Rust binding to create the multisignature account ID.\n",
    "\n",
    "Finally we convert this multi-signature account ID into a valid Substrate address.\n",
    "\n",
    "This multi-signature address is now the basis of the trade betweent the 3 participants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Multi-signature escrow address:\n",
      "HFXXfXavDuKhLLBhFQTat2aaRQ5CMMw9mwswHzWi76m6iLt\n"
     ]
    }
   ],
   "source": [
    "# Example addresses used to construct a multisig\n",
    "buyer_addr = \"CdVuGwX71W4oRbXHsLuLQxNPns23rnSSiZwZPN4etWf6XYo\"\n",
    "seller_addr = \"J9aQobenjZjwWtU2MsnYdGomvcYbgauCnBeb8xGrcqznvJc\"\n",
    "admin_addr = \"HvqnQxDQbi3LL2URh7WQfcmi8b2ZWfBhu7TEDmyyn5VK8e2\"\n",
    "\n",
    "def kusama_addr_to_account_id(address):\n",
    "    decoded_addr = ss58_decode(address)\n",
    "    return bytes.fromhex(decoded_addr)\n",
    "\n",
    "buyer_id = kusama_addr_to_account_id(buyer_addr)\n",
    "seller_id = kusama_addr_to_account_id(seller_addr)\n",
    "admin_id = kusama_addr_to_account_id(admin_addr)\n",
    "\n",
    "# Kusama protocol requires ascending numerical sort of account ID's\n",
    "trade_addresses = sorted([buyer_id, seller_id, admin_id])\n",
    "\n",
    "escrow_addr = multisig.multi_account_id(trade_addresses, 2)\n",
    "escrow_addr = ss58_encode(bytearray(escrow_addr).hex(), 2)\n",
    "\n",
    "print(f\"\\nMulti-signature escrow address:\\n{escrow_addr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 4: Sending funds into the escrow address"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The seller must now place the crypto in the multisignature escrow address.\n",
    "\n",
    "To do this we gather some information on Blockchain fees, before constructing a *transfer* call from the wallet of the seller, into the escrow address.\n",
    "\n",
    "This call is broadcast and published to the Substrate blockchain.\n",
    "\n",
    "The buyer now verifies that the crypto has been placed into escrow. In Substrate-based blockchains verifying escrow funding is relatively simple, requiring only a balance check of the escrow address. We will show this step for the sake of concept completeness."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crucial variables for the trade\n",
    "seller_keypair = sr25519.pair_from_seed(bytes.fromhex(settings.seller_hexseed))\n",
    "buyer_keypair = sr25519.pair_from_seed(bytes.fromhex(settings.buyer_hexseed))\n",
    "arbitrator_keypair = sr25519.pair_from_seed(bytes.fromhex(settings.admin_hexseed))\n",
    "\n",
    "seller_address = ss58_encode(seller_keypair[0], 2)\n",
    "buyer_address = ss58_encode(buyer_keypair[0], 2)\n",
    "arbitrator_address = ss58_encode(arbitrator_keypair[0], 2)\n",
    "\n",
    "seller_priv = seller_keypair[1].hex()\n",
    "seller_pub = ss58_decode(seller_address)\n",
    "arbitrator_priv = arbitrator_keypair[1].hex()\n",
    "arbitrator_pub = ss58_decode(arbitrator_address)\n",
    "buyer_priv = buyer_keypair[1].hex()\n",
    "buyer_pub = ss58_decode(buyer_address)\n",
    "\n",
    "# We'll consider this as a standard trade value\n",
    "trade_value = 10000000000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Fee information for a generic transaction:\n",
      "{'class': 'normal', 'partialFee': '1000000000', 'weight': 195000000}\n",
      "RUNTIME 1062\n",
      "GENESIS 0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe\n",
      "NONCE 4\n",
      "TRANSFER PAYLOAD 0x04005a989f0526b8a619b90205b6c3bef293f7b0c38fae7353afe10feae4c471255b0700e40b540200100026040000b0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafeb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe\n",
      "call_module Balances\n",
      "call_args {'dest': 'Ed7AYYmMQYRmU7sbwijGgLkRfhNYnMrBZ5epigL2c2FyBbU', 'value': 10000000000}\n",
      "call_function transfer\n",
      "SIGNATURE 0x820a0bddcf9793603c6d5abf54bfad0053adaa4d4ac5147c81135f12a699c254ea82d4ce5829d7e39910f28b6198c89b8c172398ff6e1367fd90c710a3bc3e89\n",
      "ACCOUNT ID 14097421065c7bb0efc6770ffc5d604654159d45910cc7a3cb602be16acc5528\n",
      "FINAL EXTRINSIC 0x35028414097421065c7bb0efc6770ffc5d604654159d45910cc7a3cb602be16acc552801820a0bddcf9793603c6d5abf54bfad0053adaa4d4ac5147c81135f12a699c254ea82d4ce5829d7e39910f28b6198c89b8c172398ff6e1367fd90c710a3bc3e8900100004005a989f0526b8a619b90205b6c3bef293f7b0c38fae7353afe10feae4c471255b0700e40b5402\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nresponse = await utils.node_rpc_call(\\n    \"author_submitAndWatchExtrinsic\",\\n    [str(extrinsic.data)]\\n)\\n\\nextrinsic_hash = utils.get_extrinsic_hash(str(extrinsic.data))\\nextrinsic_time_point = utils.get_time_point(response, extrinsic_hash)\\nevents = utils.get_extrinsic_events(extrinsic_time_point)\\nescrow_balance = utils.get_balance_for_address(settings.escrow_address).get(\"free\")\\n\\nprint(f\"\\nTransaction time point:\\n{extrinsic_time_point}\")\\nprint(f\"\\nTransaction hash:\\n{extrinsic_hash}\")\\n'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To gather useful fee information, we use examples of signed extrinsics of a known length\n",
    "simple_transfer = (\n",
    "    \"0x2d0284dee35cf94a50737fc2f3c60439e8bae056aabdcde99de4f2\"\n",
    "    \"d37a5f5957bcec4b01b24406f04393e57af7d7f0dc0332c0a47af5a5\"\n",
    "    \"8e4d1ed7f85448d3f0dee135361b720f4da59152e94c447ca43afb4d\"\n",
    "    \"f676af89f1c8c3625fd29e33357099bf8f006c000400dee35cf94a50\"\n",
    "    \"737fc2f3c60439e8bae056aabdcde99de4f2d37a5f5957bcec4b0228\"\n",
    "    \"6bee\"\n",
    ")\n",
    "\n",
    "\n",
    "fee_info = await utils.node_rpc_call(\"payment_queryInfo\", [simple_transfer], 1)\n",
    "fee_info = fee_info[0].get('result')\n",
    "print(f\"\\nFee information for a generic transaction:\\n{fee_info}\")\n",
    "\n",
    "call = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "\n",
    "call.encode(\n",
    "    {\n",
    "        \"call_module\": \"Balances\",\n",
    "        \"call_function\": \"transfer\",\n",
    "        \"call_args\": {\n",
    "            \"dest\": settings.escrow_address,\n",
    "            \"value\": trade_value,\n",
    "        },\n",
    "    }\n",
    ")\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [seller_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "\n",
    "# Create signature payload\n",
    "signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "\n",
    "signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(call.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    }\n",
    ")\n",
    "\n",
    "data = str(signature_payload.data)\n",
    "\n",
    "print('RUNTIME', substrate.runtime_version)\n",
    "print('GENESIS', genesis_hash)\n",
    "print('NONCE', nonce)\n",
    "print('TRANSFER PAYLOAD', data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(seller_pub), bytes.fromhex(seller_priv)), data\n",
    ")\n",
    "\n",
    "signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "# Create extrinsic\n",
    "extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "\n",
    "extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + seller_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": signature,\n",
    "        \"call_function\": call.value[\"call_function\"],\n",
    "        \"call_module\": call.value[\"call_module\"],\n",
    "        \"call_args\": call.value[\"call_args\"],\n",
    "        \"nonce\": nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    }\n",
    ")\n",
    "\n",
    "print('call_module', call.value[\"call_module\"])\n",
    "print('call_args', call.value[\"call_args\"])\n",
    "print('call_function', call.value[\"call_function\"])\n",
    "print('SIGNATURE', signature)\n",
    "print('ACCOUNT ID', seller_pub)\n",
    "print('FINAL EXTRINSIC', str(extrinsic.data))\n",
    "\"\"\"\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(extrinsic.data)]\n",
    ")\n",
    "\n",
    "extrinsic_hash = utils.get_extrinsic_hash(str(extrinsic.data))\n",
    "extrinsic_time_point = utils.get_time_point(response, extrinsic_hash)\n",
    "events = utils.get_extrinsic_events(extrinsic_time_point)\n",
    "escrow_balance = utils.get_balance_for_address(settings.escrow_address).get(\"free\")\n",
    "\n",
    "print(f\"\\nTransaction time point:\\n{extrinsic_time_point}\")\n",
    "print(f\"\\nTransaction hash:\\n{extrinsic_hash}\")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 5: Seller acknowledges receipt of funds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Safe in the knowledge that the crypto is in escrow, the buyer now makes a direct local currency transfer to the seller.\n",
    "\n",
    "Once the seller has received the payment, they then make an *approveAsMulti* call to the Substrate blockchain. This call wraps the hash of a transfer call to the buyers address.\n",
    "\n",
    "This call acknowledges the sellers desire to finalise the escrow in the buyers favour.\n",
    "\n",
    "The seller also makes a second *approveAsMulti* call, which acknowledges the trading fee given to the arbitrator.\n",
    "\n",
    "The trading fee is 1% of the value of the trade, and rewards the arbitrator for their role in safeguarding the escrow process, and paying to relay calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total trade is for 10000000000\n",
      "Total fees (1%) are 100000000\n",
      "Buyer will receive 9900000000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Prepare in advance the reusable calls\n",
    "buyer_transfer = ScaleDecoder.get_decoder_class(\"Call\", metadata=substrate.metadata_decoder)\n",
    "fee_transfer = ScaleDecoder.get_decoder_class(\"Call\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "trade_fee = int(0.01 * trade_value)\n",
    "trade_amount = trade_value - trade_fee\n",
    "\n",
    "buyer_transfer.encode(\n",
    "    {\n",
    "        \"call_module\": \"Balances\",\n",
    "        \"call_function\": \"transfer\",\n",
    "        \"call_args\": {\n",
    "            \"dest\": buyer_address,\n",
    "            \"value\": trade_amount,\n",
    "        },\n",
    "    })\n",
    "fee_transfer.encode(\n",
    "    {\n",
    "        \"call_module\": \"Balances\",\n",
    "        \"call_function\": \"transfer\",\n",
    "        \"call_args\": {\n",
    "            \"dest\": arbitrator_address,\n",
    "            \"value\": trade_fee,\n",
    "        },\n",
    "    })\n",
    "\n",
    "print(f\"Total trade is for {trade_value}\\nTotal fees (1%) are {trade_fee}\\nBuyer will receive {trade_amount}\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "to_address CofvaLbP3m8PLeNRQmLVPWmTT7jGgAXTwyT69k2wkfPxJ9V\n",
      "amount 9900000000\n",
      "hashed_buyer_transfer 0x4fb795510de9b60a094066dbfa0dc1283371735779dda481ea5d7ad7725a00f6\n",
      "signatories ['EifTqgEMBpjRD3WnV9jmdN3ArMj1JGKXAKw2eeHCSLw1Bkg', 'CofvaLbP3m8PLeNRQmLVPWmTT7jGgAXTwyT69k2wkfPxJ9V']\n",
      "nonce 4\n",
      "call_module Utility\n",
      "call_args {'call_hash': '0x4fb795510de9b60a094066dbfa0dc1283371735779dda481ea5d7ad7725a00f6', 'maybe_timepoint': None, 'other_signatories': ['CofvaLbP3m8PLeNRQmLVPWmTT7jGgAXTwyT69k2wkfPxJ9V', 'EifTqgEMBpjRD3WnV9jmdN3ArMj1JGKXAKw2eeHCSLw1Bkg'], 'threshold': 2}\n",
      "call_function approve_as_multi\n",
      "SIGNATURE PAYLOAD 0x18030200080a2ee2acc37fa96e818e2817afc104ce55770bcccb7333bbf8481d5bc3c6fa465ed592d82e3711f9b0655ed39aa591a008c04d1aada60dbb541375250dc2ff4e004fb795510de9b60a094066dbfa0dc1283371735779dda481ea5d7ad7725a00f600100026040000b0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafeb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe\n",
      "SIGNATURE 0x26ef62025f86b150442d1e1f2996dce635b591250f60a532dc32f8cf319c6515eea9bb760e442b6a816aef9fdbc535eca0d663e9b9d783a0616153df2ac0fd87\n",
      "ACCOUNT ID 14097421065c7bb0efc6770ffc5d604654159d45910cc7a3cb602be16acc5528\n",
      "FINAL EXTRINSIC 0x2d038414097421065c7bb0efc6770ffc5d604654159d45910cc7a3cb602be16acc55280126ef62025f86b150442d1e1f2996dce635b591250f60a532dc32f8cf319c6515eea9bb760e442b6a816aef9fdbc535eca0d663e9b9d783a0616153df2ac0fd8700100018030200080a2ee2acc37fa96e818e2817afc104ce55770bcccb7333bbf8481d5bc3c6fa465ed592d82e3711f9b0655ed39aa591a008c04d1aada60dbb541375250dc2ff4e004fb795510de9b60a094066dbfa0dc1283371735779dda481ea5d7ad7725a00f6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\n# Broadcast both transactions and gather timepoints\\nresponse = await utils.node_rpc_call(\\n    \"author_submitAndWatchExtrinsic\",\\n    [str(buyer_transfer_extrinsic.data)]\\n)\\nbuyer_transfer_extrinsic_hash = utils.get_extrinsic_hash(str(buyer_transfer_extrinsic.data))\\nbuyer_transfer_extrinsic_time_point = utils.get_time_point(response, buyer_transfer_extrinsic_hash)\\n\\nprint(f\"\\nBuyer transfer approveAsMulti time point:\\n{buyer_transfer_extrinsic_time_point}\")\\nprint(f\"\\nTransaction hash:\\n{buyer_transfer_extrinsic_hash}\")\\n\\nresponse = await utils.node_rpc_call(\\n    \"author_submitAndWatchExtrinsic\",\\n    [str(fee_transfer_extrinsic.data)]\\n)\\n\\nfee_transfer_extrinsic_hash = utils.get_extrinsic_hash(str(fee_transfer_extrinsic.data))\\nfee_transfer_extrinsic_time_point = utils.get_time_point(response, fee_transfer_extrinsic_hash)\\n\\nprint(f\"\\nFee transfer approveAsMulti time point:\\n{fee_transfer_extrinsic_time_point}\")\\nprint(f\"\\nTransaction hash:\\n{fee_transfer_extrinsic_hash}\")\\n'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hash_call(call):\n",
    "    call = bytes.fromhex(str(call.data)[2:])\n",
    "    return f\"0x{blake2_256(call)}\"\n",
    "\n",
    "hashed_buyer_transfer = hash_call(buyer_transfer)\n",
    "hashed_fee_transfer = hash_call(fee_transfer)\n",
    "\n",
    "buyer_transfer_approve_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder)\n",
    "fee_transfer_approve_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "buyer_transfer_approve_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"approve_as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call_hash\": hashed_buyer_transfer,\n",
    "            \"maybe_timepoint\": None,\n",
    "            \"other_signatories\": sorted(\n",
    "                [arbitrator_address, buyer_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "    })\n",
    "fee_transfer_approve_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"approve_as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call_hash\": hashed_fee_transfer,\n",
    "            \"maybe_timepoint\": None,\n",
    "            \"other_signatories\": sorted(\n",
    "                [arbitrator_address, buyer_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "    })\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [seller_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "seller_address_nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "buyer_transfer_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "buyer_transfer_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(buyer_transfer_approve_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": seller_address_nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    })\n",
    "\n",
    "fee_transfer_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "fee_transfer_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(fee_transfer_approve_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": seller_address_nonce + 1,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    })\n",
    "\n",
    "# Sign payloads\n",
    "data = str(buyer_transfer_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(seller_pub), bytes.fromhex(seller_priv)), data)\n",
    "buyer_transfer_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "data = str(fee_transfer_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(seller_pub), bytes.fromhex(seller_priv)), data)\n",
    "fee_transfer_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "\n",
    "# Create extrinsics\n",
    "buyer_transfer_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "fee_transfer_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "buyer_transfer_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + seller_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": buyer_transfer_signature,\n",
    "        \"call_function\": buyer_transfer_approve_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": buyer_transfer_approve_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": buyer_transfer_approve_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": seller_address_nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    })\n",
    "fee_transfer_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + seller_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": fee_transfer_signature,\n",
    "        \"call_function\": fee_transfer_approve_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": fee_transfer_approve_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": fee_transfer_approve_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": seller_address_nonce + 1,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    })\n",
    "\n",
    "print('to_address', buyer_address)\n",
    "print('amount', trade_amount)\n",
    "print('hashed_buyer_transfer', hashed_buyer_transfer)\n",
    "print('signatories', [arbitrator_address, buyer_address])\n",
    "print('nonce', seller_address_nonce)\n",
    "print('call_module', buyer_transfer_approve_as_multi.value[\"call_module\"])\n",
    "print('call_args', buyer_transfer_approve_as_multi.value[\"call_args\"])\n",
    "print('call_function', buyer_transfer_approve_as_multi.value[\"call_function\"])\n",
    "print('SIGNATURE PAYLOAD', str(buyer_transfer_signature_payload.data))\n",
    "print('SIGNATURE', buyer_transfer_signature)\n",
    "print('ACCOUNT ID', seller_pub)\n",
    "print('FINAL EXTRINSIC', str(buyer_transfer_extrinsic.data))\n",
    "\n",
    "\"\"\"\n",
    "# Broadcast both transactions and gather timepoints\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(buyer_transfer_extrinsic.data)]\n",
    ")\n",
    "buyer_transfer_extrinsic_hash = utils.get_extrinsic_hash(str(buyer_transfer_extrinsic.data))\n",
    "buyer_transfer_extrinsic_time_point = utils.get_time_point(response, buyer_transfer_extrinsic_hash)\n",
    "\n",
    "print(f\"\\nBuyer transfer approveAsMulti time point:\\n{buyer_transfer_extrinsic_time_point}\")\n",
    "print(f\"\\nTransaction hash:\\n{buyer_transfer_extrinsic_hash}\")\n",
    "\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(fee_transfer_extrinsic.data)]\n",
    ")\n",
    "\n",
    "fee_transfer_extrinsic_hash = utils.get_extrinsic_hash(str(fee_transfer_extrinsic.data))\n",
    "fee_transfer_extrinsic_time_point = utils.get_time_point(response, fee_transfer_extrinsic_hash)\n",
    "\n",
    "print(f\"\\nFee transfer approveAsMulti time point:\\n{fee_transfer_extrinsic_time_point}\")\n",
    "print(f\"\\nTransaction hash:\\n{fee_transfer_extrinsic_hash}\")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 6: Arbitrator finalizes trade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The multi-signature trade can now be completed, and publishing extrinsics to the Substrate blockchain requires a transaction fee. However, the buyer does not possess any crypto with which to make the transaction.\n",
    "\n",
    "To handle this, we instead have the arbitrator make the final call on their behalf.\n",
    "\n",
    "The arbitrator now constructs two *asMulti* calls, the first to finalise the escrow, and the second to receive the fee. Crucially, the timepoints of each of these calls must refer to the earlier *approveAsMulti* calls.\n",
    "\n",
    "These calls wrap the same transfer call used earlier to create the hash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timepoint 9000 1\n",
      "to_address CofvaLbP3m8PLeNRQmLVPWmTT7jGgAXTwyT69k2wkfPxJ9V\n",
      "amount 9900000000\n",
      "transfer call {'call_module': 'Balances', 'call_function': 'transfer', 'call_args': {'dest': 'CofvaLbP3m8PLeNRQmLVPWmTT7jGgAXTwyT69k2wkfPxJ9V', 'value': 9900000000}}\n",
      "signatories ['CofvaLbP3m8PLeNRQmLVPWmTT7jGgAXTwyT69k2wkfPxJ9V', 'D2bHQwFcQj11SvtkjULEdKhK4WAeP6MThXgosMHjW9DrmbE']\n",
      "nonce 5\n",
      "call_module Utility\n",
      "call_args {'call': {'call_module': 'Balances', 'call_function': 'transfer', 'call_args': {'dest': 'CofvaLbP3m8PLeNRQmLVPWmTT7jGgAXTwyT69k2wkfPxJ9V', 'value': 9900000000}}, 'maybe_timepoint': {'height': 9000, 'index': 1}, 'other_signatories': ['CofvaLbP3m8PLeNRQmLVPWmTT7jGgAXTwyT69k2wkfPxJ9V', 'D2bHQwFcQj11SvtkjULEdKhK4WAeP6MThXgosMHjW9DrmbE'], 'threshold': 2}\n",
      "call_function as_multi\n",
      "SIGNATURE PAYLOAD 0x18020200080a2ee2acc37fa96e818e2817afc104ce55770bcccb7333bbf8481d5bc3c6fa4614097421065c7bb0efc6770ffc5d604654159d45910cc7a3cb602be16acc552801282300000100000004000a2ee2acc37fa96e818e2817afc104ce55770bcccb7333bbf8481d5bc3c6fa46070003164e0200140026040000b0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafeb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe\n",
      "SIGNATURE 0x7cfbed1268b30829ab48dee7ba97c12b7c7e0c299539eb7f64a8fc69995f9d2e5f4a63f633b9e78021d30393afe085ab8f1f8479ec471a85a5ec142723b9e58e\n",
      "ACCOUNT ID 0x5ed592d82e3711f9b0655ed39aa591a008c04d1aada60dbb541375250dc2ff4e\n",
      "FINAL EXTRINSIC 0x6d03845ed592d82e3711f9b0655ed39aa591a008c04d1aada60dbb541375250dc2ff4e017cfbed1268b30829ab48dee7ba97c12b7c7e0c299539eb7f64a8fc69995f9d2e5f4a63f633b9e78021d30393afe085ab8f1f8479ec471a85a5ec142723b9e58e00140018020200080a2ee2acc37fa96e818e2817afc104ce55770bcccb7333bbf8481d5bc3c6fa4614097421065c7bb0efc6770ffc5d604654159d45910cc7a3cb602be16acc552801282300000100000004000a2ee2acc37fa96e818e2817afc104ce55770bcccb7333bbf8481d5bc3c6fa46070003164e02\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\nresponse = await utils.node_rpc_call(\\n    \"author_submitAndWatchExtrinsic\",\\n    [str(buyer_extrinsic.data)]\\n)\\n\\nbuyer_extrinsic_hash = utils.get_extrinsic_hash(str(buyer_extrinsic.data))\\nbuyer_extrinsic_time_point = utils.get_time_point(response, buyer_extrinsic_hash)\\n\\nprint(f\"\\nArbitrator as_multi time point:\\n{buyer_extrinsic_time_point}\")\\nprint(f\"\\nas_multi hash:\\n{buyer_extrinsic_hash}\")\\n\\nresponse = await utils.node_rpc_call(\\n    \"author_submitAndWatchExtrinsic\",\\n    [str(fee_extrinsic.data)]\\n)\\n\\nfee_extrinsic_hash = utils.get_extrinsic_hash(str(fee_extrinsic.data))\\nfee_extrinsic_time_point = utils.get_time_point(response, fee_extrinsic_hash)\\n\\nprint(f\"\\nArbitrator fee as_multi time point:\\n{fee_extrinsic_time_point}\")\\nprint(f\"\\nas_multi fee hash:\\n{fee_extrinsic_hash}\")\\n'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buyer_transfer_extrinsic_time_point = (9000, 1)\n",
    "fee_transfer_extrinsic_time_point = (9000, 1)\n",
    "buyer_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "buyer_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call\": buyer_transfer.serialize(),\n",
    "            \"maybe_timepoint\": {\n",
    "                \"height\": buyer_transfer_extrinsic_time_point[0],\n",
    "                \"index\": buyer_transfer_extrinsic_time_point[1],\n",
    "            },\n",
    "            \"other_signatories\": sorted(\n",
    "                [buyer_address, seller_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "})\n",
    "fee_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "fee_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call\": fee_transfer.serialize(),\n",
    "            \"maybe_timepoint\": {\n",
    "                \"height\": fee_transfer_extrinsic_time_point[0],\n",
    "                \"index\": fee_transfer_extrinsic_time_point[1],\n",
    "            },\n",
    "            \"other_signatories\": sorted(\n",
    "                [buyer_address, seller_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "})\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [arbitrator_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "arbitrator_nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "# Create signature payload\n",
    "buyer_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "buyer_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(buyer_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": arbitrator_nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    }\n",
    ")\n",
    "\n",
    "fee_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "fee_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(fee_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": arbitrator_nonce + 1,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    }\n",
    ")\n",
    "\n",
    "# Sign payload\n",
    "data = str(buyer_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(arbitrator_pub), bytes.fromhex(arbitrator_priv)), data)\n",
    "\n",
    "buyer_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "data = str(fee_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(arbitrator_pub), bytes.fromhex(arbitrator_priv)), data)\n",
    "\n",
    "fee_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "# Create extrinsic\n",
    "buyer_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "fee_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "buyer_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + arbitrator_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": buyer_signature,\n",
    "        \"call_function\": buyer_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": buyer_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": buyer_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": arbitrator_nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    }\n",
    ")\n",
    "\n",
    "fee_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + arbitrator_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": fee_signature,\n",
    "        \"call_function\": fee_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": fee_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": fee_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": arbitrator_nonce + 1,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    }\n",
    ")\n",
    "\n",
    "print('timepoint', buyer_transfer_extrinsic_time_point[0], buyer_transfer_extrinsic_time_point[1])\n",
    "print('to_address', buyer_address)\n",
    "print('amount', trade_amount)\n",
    "print('transfer call', buyer_transfer.serialize())\n",
    "print('signatories', [buyer_address, seller_address])\n",
    "print('nonce', arbitrator_nonce)\n",
    "print('call_module', buyer_as_multi.value[\"call_module\"])\n",
    "print('call_args', buyer_as_multi.value[\"call_args\"])\n",
    "print('call_function', buyer_as_multi.value[\"call_function\"])\n",
    "print('SIGNATURE PAYLOAD', str(buyer_signature_payload.data))\n",
    "print('SIGNATURE', buyer_signature)\n",
    "print('ACCOUNT ID', '0x'+arbitrator_pub)\n",
    "print('FINAL EXTRINSIC', str(buyer_extrinsic.data))\n",
    "\n",
    "\"\"\"\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(buyer_extrinsic.data)]\n",
    ")\n",
    "\n",
    "buyer_extrinsic_hash = utils.get_extrinsic_hash(str(buyer_extrinsic.data))\n",
    "buyer_extrinsic_time_point = utils.get_time_point(response, buyer_extrinsic_hash)\n",
    "\n",
    "print(f\"\\nArbitrator as_multi time point:\\n{buyer_extrinsic_time_point}\")\n",
    "print(f\"\\nas_multi hash:\\n{buyer_extrinsic_hash}\")\n",
    "\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(fee_extrinsic.data)]\n",
    ")\n",
    "\n",
    "fee_extrinsic_hash = utils.get_extrinsic_hash(str(fee_extrinsic.data))\n",
    "fee_extrinsic_time_point = utils.get_time_point(response, fee_extrinsic_hash)\n",
    "\n",
    "print(f\"\\nArbitrator fee as_multi time point:\\n{fee_extrinsic_time_point}\")\n",
    "print(f\"\\nas_multi fee hash:\\n{fee_extrinsic_hash}\")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 7: Cancelling a trade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this situation the crypto has been placed in escrow, and both parties consent to the cancellation of the trade, and thus the return of the funds to the seller.\n",
    "\n",
    "As in the standard trade, we publish two transactions to the Blockchain, the first an approveAsMulti call for the transfer back to the seller, and the second asMulti call published by the arbitrator.\n",
    "\n",
    "In this situation no fee is charged by the arbitrator. For the sake of cluttering the code less, we will not show the fee transaction in this situation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seller_transfer = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "# In this case the dest is back to the seller_address\n",
    "seller_transfer.encode(\n",
    "    {\n",
    "        \"call_module\": \"Balances\",\n",
    "        \"call_function\": \"transfer\",\n",
    "        \"call_args\": {\n",
    "            \"dest\": seller_address,\n",
    "            \"value\": trade_value,\n",
    "        },\n",
    "    })\n",
    "\n",
    "\n",
    "def hash_call(call):\n",
    "    call = bytes.fromhex(str(call.data)[2:])\n",
    "    return f\"0x{blake2_256(call)}\"\n",
    "\n",
    "hashed_seller_transfer = hash_call(seller_transfer)\n",
    "\n",
    "seller_transfer_approve_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "seller_transfer_approve_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"approve_as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call_hash\": hashed_seller_transfer,\n",
    "            \"maybe_timepoint\": None,\n",
    "            \"other_signatories\": sorted(\n",
    "                [arbitrator_address, buyer_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "    })\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [seller_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "seller_address_nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "seller_transfer_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "seller_transfer_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(seller_transfer_approve_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": seller_address_nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    })\n",
    "\n",
    "# Sign payloads\n",
    "data = str(seller_transfer_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(seller_pub), bytes.fromhex(seller_priv)), data)\n",
    "seller_transfer_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "# Create extrinsics\n",
    "seller_transfer_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "seller_transfer_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + seller_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": seller_transfer_signature,\n",
    "        \"call_function\": seller_transfer_approve_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": seller_transfer_approve_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": seller_transfer_approve_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": seller_address_nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    })\n",
    "\n",
    "# Broadcast transaction and gather timepoint\n",
    "\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(seller_transfer_extrinsic.data)]\n",
    ")\n",
    "seller_transfer_extrinsic_hash = utils.get_extrinsic_hash(str(seller_transfer_extrinsic.data))\n",
    "seller_transfer_extrinsic_time_point = utils.get_time_point(response, seller_transfer_extrinsic_hash)\n",
    "\n",
    "print(f\"\\nSeller transfer approveAsMulti time point:\\n{seller_transfer_extrinsic_time_point}\")\n",
    "print(f\"\\nTransaction hash:\\n{seller_transfer_extrinsic_hash}\")\n",
    "\n",
    "\n",
    "####################################################################################\n",
    "# We call asMulti like before. In this case we want to transfer back to the seller #\n",
    "####################################################################################\n",
    "\n",
    "\n",
    "seller_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "seller_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call\": seller_transfer.serialize(),\n",
    "            \"maybe_timepoint\": {\n",
    "                \"height\": seller_transfer_extrinsic_time_point[0],\n",
    "                \"index\": seller_transfer_extrinsic_time_point[1],\n",
    "            },\n",
    "            \"other_signatories\": sorted(\n",
    "                [buyer_address, seller_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "})\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [arbitrator_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "arbitrator_nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "# Create signature payload\n",
    "seller_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "seller_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(seller_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": arbitrator_nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    }\n",
    ")\n",
    "\n",
    "# Sign payload\n",
    "data = str(seller_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "\n",
    "seller_signature_payload = sr25519.sign(\n",
    "    (bytes.fromhex(arbitrator_pub), bytes.fromhex(arbitrator_priv)), data)\n",
    "\n",
    "seller_signature_payload = \"0x{}\".format(seller_signature_payload.hex())\n",
    "\n",
    "# Create extrinsic\n",
    "seller_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "seller_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + arbitrator_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": seller_signature_payload,\n",
    "        \"call_function\": seller_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": seller_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": seller_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": arbitrator_nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    }\n",
    ")\n",
    "\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(seller_extrinsic.data)]\n",
    ")\n",
    "\n",
    "seller_extrinsic_hash = utils.get_extrinsic_hash(str(seller_extrinsic.data))\n",
    "seller_extrinsic_time_point = utils.get_time_point(response, seller_extrinsic_hash)\n",
    "\n",
    "print(f\"\\nArbitrator transfer as_multi time point:\\n{seller_extrinsic_time_point}\")\n",
    "print(f\"\\nTransaction hash:\\n{seller_extrinsic_hash}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 8: Disputes between the buyer and seller"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this situation the buyer and seller has come to a disagreement about the rightful owner of the funds. Either the buyer or seller raises a *dispute ticket*, and asks the arbitrator to come to a decision about the rightful owner of the funds.\n",
    "\n",
    "In the situation where the arbitrator decides that the seller is the rightful owner, the transaction flow is the same as in the cancellation example.\n",
    "\n",
    "However, in the event that the buyer is the rightful owner, it can be assumed that the seller will be unwilling to publish an *approveAsMulti* transaction on the buyers behalf.\n",
    "\n",
    "Therefore, the arbitrator prepares three transactions.\n",
    "\n",
    "The first transaction is the simple transfer of a small amount of funds to the buyer, in order that they can pay for transaction fees.\n",
    "\n",
    "The second transaction is an *approveAsMulti* call for the fee which is paid to the arbitrator.\n",
    "\n",
    "The third transaction is an *approveAsMulti* call for the rest of the funds to travel to the buyer.\n",
    "\n",
    "The arbitrator publishes the first two transactions, and then awaits the buyer to publish an *asMulti* transaction for the fee.\n",
    "\n",
    "Once this occurs, the arbitrator publishes the final transaction, and the buyer then also finalises this with their own *asMulti* transaction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#########################################################################################\n",
    "# The first transaction is the simple transfer of a small amount of funds to the buyer, #\n",
    "# in order that they can pay for transaction fees.                                      #\n",
    "#########################################################################################\n",
    "\n",
    "\n",
    "# We'll consider this as the fee value for the 2 asMulti calls for fee to be sent to \n",
    "# the arbitrator and the rest of the funds to travel to the buyer\n",
    "dispute_fee_value = 2000000000\n",
    "\n",
    "call = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "\n",
    "call.encode(\n",
    "    {\n",
    "        \"call_module\": \"Balances\",\n",
    "        \"call_function\": \"transfer\",\n",
    "        \"call_args\": {\n",
    "            \"dest\": buyer_address,\n",
    "            \"value\": dispute_fee_value,\n",
    "        },\n",
    "    }\n",
    ")\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [arbitrator_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "# Create signature payload\n",
    "signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(call.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    }\n",
    ")\n",
    "\n",
    "data = str(signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(arbitrator_pub), bytes.fromhex(arbitrator_priv)), data\n",
    ")\n",
    "\n",
    "signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "# Create extrinsic\n",
    "extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "\n",
    "extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + arbitrator_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": signature,\n",
    "        \"call_function\": call.value[\"call_function\"],\n",
    "        \"call_module\": call.value[\"call_module\"],\n",
    "        \"call_args\": call.value[\"call_args\"],\n",
    "        \"nonce\": nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    }\n",
    ")\n",
    "\n",
    "response = utils.rpc_subscription(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(extrinsic.data)],\n",
    "    substrate.request_id,\n",
    "    settings.NODE_URL,\n",
    ")\n",
    "\n",
    "extrinsic_hash = utils.get_extrinsic_hash(str(extrinsic.data))\n",
    "extrinsic_time_point = utils.get_time_point(response, extrinsic_hash)\n",
    "events = utils.get_extrinsic_events(extrinsic_time_point)\n",
    "buyer_balance = utils.get_balance_for_address(buyer_address).get(\"free\")\n",
    "\n",
    "print(f\"\\nTransaction time point:\\n{extrinsic_time_point}\")\n",
    "print(f\"\\nTransaction hash:\\n{extrinsic_hash}\")\n",
    "print(f\"\\nEvents returned from published transaction:\\n{events}\")\n",
    "\n",
    "###############################################################################################\n",
    "# Second transaction is an *approveAsMulti* call for the fee which is paid to the arbitrator. #\n",
    "###############################################################################################\n",
    "\n",
    "fee_transfer = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "trade_fee = int(0.01 * trade_value)\n",
    "trade_amount = trade_value - trade_fee\n",
    "\n",
    "print(f\"Total trade is for {trade_value}\\nTotal fees (1%) are {trade_fee}\\nBuyer will receive {trade_amount}\\n\")\n",
    "\n",
    "\n",
    "fee_transfer.encode(\n",
    "    {\n",
    "        \"call_module\": \"Balances\",\n",
    "        \"call_function\": \"transfer\",\n",
    "        \"call_args\": {\n",
    "            \"dest\": arbitrator_address,\n",
    "            \"value\": trade_fee,\n",
    "        },\n",
    "    })\n",
    "\n",
    "def hash_call(call):\n",
    "    call = bytes.fromhex(str(call.data)[2:])\n",
    "    return f\"0x{blake2_256(call)}\"\n",
    "\n",
    "hashed_fee_transfer = hash_call(fee_transfer)\n",
    "\n",
    "fee_transfer_approve_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "fee_transfer_approve_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"approve_as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call_hash\": hashed_fee_transfer,\n",
    "            \"maybe_timepoint\": None,\n",
    "            \"other_signatories\": sorted(\n",
    "                [seller_address, buyer_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "    })\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [arbitrator_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "arbitrator_address_nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "fee_transfer_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "fee_transfer_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(fee_transfer_approve_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": arbitrator_address_nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    })\n",
    "\n",
    "# Sign payloads\n",
    "\n",
    "data = str(fee_transfer_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(arbitrator_pub), bytes.fromhex(arbitrator_priv)), data)\n",
    "fee_transfer_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "\n",
    "# Create extrinsics\n",
    "fee_transfer_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "fee_transfer_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + arbitrator_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": fee_transfer_signature,\n",
    "        \"call_function\": fee_transfer_approve_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": fee_transfer_approve_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": fee_transfer_approve_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": arbitrator_address_nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    })\n",
    "\n",
    "# Broadcast transaction and gather timepoint\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(fee_transfer_extrinsic.data)]\n",
    ")\n",
    "\n",
    "fee_transfer_extrinsic_hash = utils.get_extrinsic_hash(str(fee_transfer_extrinsic.data))\n",
    "fee_transfer_extrinsic_time_point = utils.get_time_point(response, fee_transfer_extrinsic_hash)\n",
    "\n",
    "\n",
    "print(f\"\\nBuyer transfer approveAsMulti time point:\\n{fee_transfer_extrinsic_time_point}\")\n",
    "print(f\"\\nTransaction hash:\\n{fee_transfer_extrinsic_hash}\")\n",
    "\n",
    "################################################################################\n",
    "# Arbitrator awaits the buyer to publish an *asMulti* transaction for the fee. #\n",
    "################################################################################\n",
    "\n",
    "fee_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "fee_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call\": fee_transfer.serialize(),\n",
    "            \"maybe_timepoint\": {\n",
    "                \"height\": fee_transfer_extrinsic_time_point[0],\n",
    "                \"index\": fee_transfer_extrinsic_time_point[1],\n",
    "            },\n",
    "            \"other_signatories\": sorted(\n",
    "                [arbitrator_address, seller_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "})\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [buyer_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "buyer_nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "# Create signature payload\n",
    "fee_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "\n",
    "fee_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(fee_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": arbitrator_nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    }\n",
    ")\n",
    "\n",
    "# Sign payload\n",
    "data = str(fee_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(buyer_pub), bytes.fromhex(buyer_priv)), data)\n",
    "\n",
    "fee_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "# Create extrinsic\n",
    "fee_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + buyer_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": fee_signature,\n",
    "        \"call_function\": fee_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": fee_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": fee_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": arbitrator_nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    }\n",
    ")\n",
    "\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(fee_extrinsic.data)]\n",
    ")\n",
    "\n",
    "fee_extrinsic_hash = utils.get_extrinsic_hash(str(fee_extrinsic.data))\n",
    "fee_extrinsic_time_point = utils.get_time_point(response, fee_extrinsic_hash)\n",
    "\n",
    "print(f\"\\nBuyer fee as_multi time point:\\n{fee_extrinsic_time_point}\")\n",
    "print(f\"\\nas_multi fee hash:\\n{fee_extrinsic_hash}\")\n",
    "\n",
    "################################################################################\n",
    "# Now that the fees are handled the arbitrator publishes the final transaction #\n",
    "################################################################################\n",
    "\n",
    "buyer_transfer = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "buyer_transfer.encode(\n",
    "    {\n",
    "        \"call_module\": \"Balances\",\n",
    "        \"call_function\": \"transfer\",\n",
    "        \"call_args\": {\n",
    "            \"dest\": buyer_address,\n",
    "            \"value\": trade_amount,\n",
    "        },\n",
    "    })\n",
    "\n",
    "hashed_buyer_transfer = hash_call(buyer_transfer)\n",
    "\n",
    "buyer_transfer_approve_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "buyer_transfer_approve_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"approve_as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call_hash\": hashed_buyer_transfer,\n",
    "            \"maybe_timepoint\": None,\n",
    "            \"other_signatories\": sorted(\n",
    "                [seller_address, buyer_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "    })\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [arbitrator_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "arbitrator_address_nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "\n",
    "buyer_transfer_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "buyer_transfer_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(buyer_transfer_approve_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": arbitrator_address_nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    })\n",
    "\n",
    "# Sign payloads\n",
    "data = str(buyer_transfer_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(arbitrator_pub), bytes.fromhex(arbitrator_priv)), data)\n",
    "buyer_transfer_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "# Create extrinsics\n",
    "buyer_transfer_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "buyer_transfer_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + arbitrator_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": buyer_transfer_signature,\n",
    "        \"call_function\": buyer_transfer_approve_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": buyer_transfer_approve_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": buyer_transfer_approve_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": arbitrator_address_nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    })\n",
    "\n",
    "# Broadcast transaction and gather timepoint\n",
    "\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(buyer_transfer_extrinsic.data)]\n",
    ")\n",
    "buyer_transfer_extrinsic_hash = utils.get_extrinsic_hash(str(buyer_transfer_extrinsic.data))\n",
    "buyer_transfer_extrinsic_time_point = utils.get_time_point(response, buyer_transfer_extrinsic_hash)\n",
    "\n",
    "print(f\"\\nBuyer transfer approveAsMulti time point:\\n{buyer_transfer_extrinsic_time_point}\")\n",
    "print(f\"\\nTransaction hash:\\n{buyer_transfer_extrinsic_hash}\")\n",
    "\n",
    "####################################################################\n",
    "# Buyer now finalises dispute with their own *asMulti* transaction #\n",
    "####################################################################\n",
    "\n",
    "buyer_as_multi = ScaleDecoder.get_decoder_class(\n",
    "    \"Call\", metadata=substrate.metadata_decoder\n",
    ")\n",
    "buyer_as_multi.encode(\n",
    "    {\n",
    "        \"call_module\": \"Utility\",\n",
    "        \"call_function\": \"as_multi\",\n",
    "        \"call_args\": {\n",
    "            \"call\": buyer_transfer.serialize(),\n",
    "            \"maybe_timepoint\": {\n",
    "                \"height\": buyer_transfer_extrinsic_time_point[0],\n",
    "                \"index\": buyer_transfer_extrinsic_time_point[1],\n",
    "            },\n",
    "            \"other_signatories\": sorted(\n",
    "                [arbitrator_address, seller_address]\n",
    "            ),\n",
    "            \"threshold\": 2,\n",
    "        },\n",
    "})\n",
    "\n",
    "response = substrate.get_runtime_state(\n",
    "    \"System\", \"Account\", [buyer_address]\n",
    ")\n",
    "assert response.get(\"result\")\n",
    "buyer_address_nonce = response[\"result\"].get(\"nonce\", 0)\n",
    "\n",
    "\n",
    "# Create signature payload\n",
    "\n",
    "buyer_signature_payload = ScaleDecoder.get_decoder_class(\"ExtrinsicPayloadValue\")\n",
    "\n",
    "buyer_signature_payload.encode(\n",
    "    {\n",
    "        \"call\": str(buyer_as_multi.data),\n",
    "        \"era\": \"00\",\n",
    "        \"nonce\": buyer_address_nonce,\n",
    "        \"tip\": 0,\n",
    "        \"specVersion\": substrate.runtime_version,\n",
    "        \"genesisHash\": genesis_hash,\n",
    "        \"blockHash\": genesis_hash,\n",
    "    }\n",
    ")\n",
    "\n",
    "# Sign payload\n",
    "data = str(buyer_signature_payload.data)\n",
    "data = bytes.fromhex(data[2:])\n",
    "\n",
    "signature = sr25519.sign(\n",
    "    (bytes.fromhex(buyer_pub), bytes.fromhex(buyer_priv)), data)\n",
    "\n",
    "buyer_signature = \"0x{}\".format(signature.hex())\n",
    "\n",
    "# Create extrinsic\n",
    "buyer_extrinsic = ScaleDecoder.get_decoder_class(\n",
    "    \"Extrinsic\", metadata=substrate.metadata_decoder)\n",
    "\n",
    "buyer_extrinsic.encode(\n",
    "    {\n",
    "        \"account_id\": \"0x\" + arbitrator_pub,\n",
    "        \"signature_version\": 1,\n",
    "        \"signature\": buyer_signature,\n",
    "        \"call_function\": buyer_as_multi.value[\"call_function\"],\n",
    "        \"call_module\": buyer_as_multi.value[\"call_module\"],\n",
    "        \"call_args\": buyer_as_multi.value[\"call_args\"],\n",
    "        \"nonce\": buyer_address_nonce,\n",
    "        \"era\": \"00\",\n",
    "        \"tip\": 0,\n",
    "    }\n",
    ")\n",
    "\n",
    "response = await utils.node_rpc_call(\n",
    "    \"author_submitAndWatchExtrinsic\",\n",
    "    [str(buyer_extrinsic.data)]\n",
    ")\n",
    "\n",
    "buyer_extrinsic_hash = utils.get_extrinsic_hash(str(buyer_extrinsic.data))\n",
    "buyer_extrinsic_time_point = utils.get_time_point(response, buyer_extrinsic_hash)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 9: Reference summation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code demonstrates the exact steps involved in the non-custodial trading process. However, there are a couple of additional factors which an exchange must take into consideration for an integration. I will go over a few of them:\n",
    "\n",
    "**Changes to the Substrate blockchain**  \n",
    "Substrate blockchains avoid the need for hard forks by having the ability to radicaly change their own runtime codebases. To keep on top of this, it is imperative that our exchange tracks the latest version of the Substrate runtime using the `system_lastRuntimeUpgrade` variable, and runs the tests in this reference each time a codebase change occurs.\n",
    "\n",
    "**Threshold transaction values**  \n",
    "Substrate blockchains require that the initiating party in a trade has an account balance of `0.3 + 0.05 * threshold` token, the threshold in a 3 person multi-signature trade being 2. Therefore, we set a minimum trade value of 1 token to safely handle all edge-cases that might occur.\n",
    "\n",
    "**Diagnostics and resolutions for failed trade transactions**  \n",
    "For various reasons, an `approveAsMulti` or `asMulti` transaction might fail. Common errors include:\n",
    "\n",
    "*No timepoint specified, yet the operation is already underway*    \n",
    "A successfull transaction was already pushed from the same address. The exchange should find the previous transaction, and manually progress the escrow process with the correct timepoint.\n",
    "\n",
    "*The timepoint refers to a different transaction than the one underway*  \n",
    "The timepoint being used is incorrect, the trade should be manually progressed after the correct timepoint is found\n",
    "\n",
    "*Signatories incorrectly sorted*  \n",
    "A sort command must be run on the signatories list before re-pushing\n",
    "\n",
    "*Insufficient signatories*  \n",
    "In this rather deceptive error message the seller has insufficient balance for the trade. The sellers account balance must be increased before the transaction is pushed again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}