aleeusgr / potential-robot

minimal dApp testing suite

Hi there 👋

I am Alex, a cybertramp, a founder of Tarax DAO and a co-founder of Intersect MBO.

• 💻 I've been coding since I was a kid, starting with BASIC and Pascal.
• 🌱 I’m currently learning Software Verification, Contemporary Mathematical Thinking and Ontology of Money.
• 🤯 Fun fact: Money is pre-eminently a political category.

potential-robot's Issues

CTL

• https://github.com/Plutonomicon/cardano-transaction-lib#readme
• https://github.com/Plutonomicon/cardano-transaction-lib/blob/develop/doc/getting-started.md#setting-up-a-new-project
• [ ]

lucid.test.ts

https://www.npmjs.com/package/lucid-cardano

example code: #38
#43

Testing techniques

Lucid: interact with a plutus script

ScriptContext

• https://www.hyperion-bt.org/helios-book/lang/builtins/scriptcontext.html
• https://www.hyperion-bt.org/helios-book/lang/script-structure.html
• It wraps the Tx type and provides some extra methods.
• L18, how do I print stuff? Book p116

further exploration

• test-time API and test runner,
• test tracer

helios testing harness example

<@930457726323138570> This is my full test file for a vault SC

import { describe, it, beforeAll, expect } from 'vitest'
import { Program, Address, NetworkEmulator, ConstrData } from "@hyperionbt/helios"
import fs from "fs";

let program;
let testContract;

describe('Raffle Vault works appropriately', () => {


    beforeAll(() => {

        const testSetup = {
            contract: './components/Contracts/vault.hl',
            fixtures: [
                './tests/vault_fixtures.hl'
            ],
            helpers: [
            ],
            // replacements: [
            //     []
            // ]
        }

        const contractSources: string[] = []

        contractSources.push(
            fs.readFileSync(testSetup.contract).toString()
        )

        testSetup.fixtures.forEach(fixture => contractSources.push(fs.readFileSync(fixture).toString()))

        const source = contractSources
            .join("\n")
            .replace('context.get_current_validator_hash()', 'ValidatorHash::new(#01234567890123456789012345678901234567890123456789000001)')

        program = Program.new(source);
        testContract = program.compile();
    })


    it(`should allow Admin to spend`, async () => {

        const args = ["datum", "admin", "sc_admin_signed"].map((p) => program.evalParam(p))
        return await testContract
            .runWithPrint(args)
            .then((res) => {
                console.log('res', JSON.stringify(res))
                expect(res[0].toString()).toBe("()");
            })
    })

    it(`should allow Winner to spend`, async () => {

        const args = ["datum", "winner", "sc_winner_signed"].map((p) => program.evalParam(p))
        return await testContract
            .runWithPrint(args)
            .then((res) => {
                console.log('res', JSON.stringify(res))
                expect(res[0].toString()).toBe("()");
            })
    })

    it(`should forbid admin to spend if signed as winner`, async () => {
        const args = ["datum", "admin", "sc_winner_signed"].map((p) => program.evalParam(p))
        return await testContract
            .runWithPrint(args)
            .then((res) => {
                expect(res[1]).toContain('TRACE_IS_ADMIN: false')
                expect(res[0].toString()).not.toBe("()")
            })
    })

    it(`should forbid winner to spend if signed as admin`, async () => {
        const args = ["datum", "winner", "sc_admin_signed"].map((p) => program.evalParam(p))
        return await testContract
            .runWithPrint(args)
            .then((res) => {
                expect(res[1]).toContain('TRACE_IS_WINNER: false')
                expect(res[0].toString()).not.toBe("()")
            })
    })

    it(`should forbid other to spend if signed as admin`, async () => {
        const args = ["datum", "admin", "sc_loser_signed"].map((p) => program.evalParam(p))
        return await testContract
            .runWithPrint(args)
            .then((res) => {
                expect(res[1]).toContain('TRACE_IS_ADMIN: false')
                expect(res[0].toString()).not.toBe("()")
            })
    })

    it(`should forbid other to spend if signed as winner`, async () => {
        const args = ["datum", "winner", "sc_loser_signed"].map((p) => program.evalParam(p))
        return await testContract
            .runWithPrint(args)
            .then((res) => {
                expect(res[1]).toContain('TRACE_IS_WINNER: false')
                expect(res[0].toString()).not.toBe("()")
            })
    })

})

https://discord.com/channels/997177025972424815/1092933893096755301/1093785314792845344

plutus-apps

https://github.com/input-output-hk/plutus-apps/tree/main/plutus-contract

https://github.com/input-output-hk/plutus-apps/tree/main/plutus-example

https://github.com/input-output-hk/plutus-apps/tree/main/plutus-contract-certification

https://github.com/input-output-hk/plutus-apps/tree/8f039edf0b6aec336dbc338af756d7eca5010819/cardano-node-emulator

Helios: first glance

https://www.hyperion-bt.org/helios-book/api/setup.html

Formal Verification

• format

CoQ, yices, Z3 and the whole world of tools and methods.
I think I have a good book in my old laptop, any heads up on tooling to look into?

Or contract model is all you need?

Thank you, 🙏

CoQ is far from being automated 😅 yices and z3 would need to do some development to translate from Plutus (or another programming language) to SMT lib and embedding the behavior of the ledger as well

https://discord.com/channels/1029837832350605343/1030116075532206101/1097197231909646447

Helios: wallet emulator

Suggestion by Lawrence Ley:

<@930457726323138570> I decided to create a quick example that uses a Helios network emulator as a node.js app and how this could be a starting point for unit/integration/automated testing. If combined with Vitest, I think this can be very helpful in certifying applications.
https://github.com/lley154/helios-examples/tree/main/emulator

https://www.hyperion-bt.org/helios-book/api/reference/networkemulator.html

https://gav.hashnode.dev/coinselection-part1

test Deno

nix-shell -p deno

Deno aims to be a productive and secure scripting environment for the modern programmer. Deno will always be distributed as a single executable. Given a URL to a Deno program, it is runnable with nothing more than the ~15 megabyte zipped executable. Deno explicitly takes on the role of both runtime and package manager. It uses a standard browser-compatible protocol for loading modules: URLs. Among other things, Deno is a great replacement for utility scripts that may have been historically written with bash or python.

Lucid: emulator logging

https://lucid.spacebudz.io/docs/getting-started/test-emulate/

lc architecture and overview

• https://github.com/OpenLitterMap/openlittermap-web/tree/staging/littercoin

lockAda

lender deposits funds + asset-id of an NFT that will be the collateral

compare:
lockAda

creates a datum and populates it with form values and the PKH of the owner wallet.

• https://github.com/lley154/helios-examples/blob/main/vesting/pages/index.tsx
• https://github.com/lley154/helios-examples/blob/main/vesting/components/LockAda.tsx
• does not need a Redeemer?

mesh

https://meshjs.dev/

https://github.com/MeshJS/mesh

https://github.com/MeshJS/starter-next-ts-template/blob/db863570cbcb788d68577ef7e2352f66092ac973/package.json#L8-L13

find line 153

look at package.json

search "javascript enrtypoint"

Quora.

Sidenote: I see my nvim config didn't port properly! adding to migration

npm run dev is an alias for next dev
$find app ❌

https://stackoverflow.com/questions/59917507/where-is-entry-point-of-nextjs-application

https://github.com/aleeusgr/potential-robot/pull/16/files
pages/index.tsx

add a smart contract into the emulator

#74

Lucid: get uplc

cborHex? hardcoded
#67

claimLoan

How to create Datum and Redeemer?

• #83
• aleeusgr/sniffle#1

Emulator

• #42
• #38
• https://github.com/spacebudz/lucid/blob/main/src/provider/emulator.ts
• matching_keyhash
• RTFM

tweag

https://github.com/tweag/cooked-smart-contracts

https://github.com/tweag/cooked-validators

create nix scaffolding

https://johns.codes/blog/building-typescript-node-apps-with-nix

koral

https://github.com/koralabs/handles-personalization/tree/master/simple_example_wth_tests

helios-loader

Import Helios directly in JS/TS;
server-side/ client-side??
https://github.com/Hyperion-BT/helios-loader

testing in browser

• https://github.com/Plutonomicon/cardano-transaction-lib/blob/develop/doc/e2e-testing.md

https://vitest.dev/guide/browser.html

minting test

https://gitlab.com/cardano-toolbox/templates/gimbalabs-token-minter

linter

https://github.com/typicode/husky

rust Cardano

https://github.com/free-honey/naumachia

testing techniques

instantiate the emulator

potential-robot/tests/lucid.test.ts

Lines 38 to 54 in 6ec5a28

	// https://github.com/spacebudz/lucid/blob/main/tests/emulator.test.ts
	async function generateAccount(assets: Assets) {
	const seedPhrase = generateSeedPhrase();
	return {
	seedPhrase,
	address: await (await Lucid.new(undefined, "Custom"))
	.selectWalletFromSeed(seedPhrase).wallet.address(),
	assets,
	};
	}
	const lender = await generateAccount({ lovelace: 75000000000n });
	const borrower = await generateAccount({ lovelace: 100000000n });
	const emulator = new Emulator([lender, borrower]);
	const lucid = await Lucid.new(emulator);

Naming!

submit a transaction

potential-robot/tests/lucid.test.ts

Lines 56 to 62 in 6ec5a28

	lucid.selectWalletFromSeed(lender.seedPhrase);
	const recipient =
	"addr_test1qrupyvhe20s0hxcusrzlwp868c985dl8ukyr44gfvpqg4ek3vp92wfpentxz4f853t70plkp3vvkzggjxknd93v59uysvc54h7";
	// this needs to change.
	const datum = Data.to(123n);
	const lovelace = 3000000n;

potential-robot/tests/lucid.test.ts

Lines 64 to 70 in 6ec5a28

	const tx = await lucid.newTx().payToAddressWithData(recipient, {
	inline: datum,
	}, { lovelace }).complete();
	const signedTx = await tx.sign().complete();
	const txHash = await signedTx.submit();
	await lucid.awaitTx(txHash);

query plutus script

https://lucid.spacebudz.io/docs/getting-started/smart-contract/#read-utxos-and-plutus-scripts

review

• what would be the simplest test?
• src/mint.mjs
• tests/mint-onchain...

a transaction

collect values
populate datum
tx_build;

potential-robot/tests/lucid-emulator-script.test.ts

Line 95 in ea5af2b

.collectFrom([utxo], Redeemer(number))

test refactoring

how is test environment being set up?
beforeAll - more speed, less accurate; go for accurate first;
use beforeEach:

• #56
• add nft
  • get uplc (#33, .. )

it: what are the tests?

• check the emulator instance
• run a transaction (#53, ..)

docs

https://vitest.dev/guide/

https://vitest.dev/api/#beforeeach

https://en.wikipedia.org/wiki/Callback_(computer_programming)

plutus-simple-model

|-- plutus-simple-model
|--|--psm
|--|--cardano-simple

set up testing framework

The requirement is to be able to run tests on a compiled cborhex

• plutus-simple-model
  - [ ] cardano-node-tests

Later:

• cardno-node-emulator
• nix flake init -t github:LovelaceAcademy/nix-templates#plutus

validation

validation is a process that is described in a plutus script.

• https://www.hyperion-bt.org/helios-book/lang/script-structure.html
• https://www.hyperion-bt.org/helios-book/lang/script-structure.html#data-generators-and-test-functions-5
  take data from Datum, perfom some logic on it, return True or False

Documentation

Audit best practices

dApp registration process

dApp registration metadata

modularize

plutip

• run plutip
• #30
• https://github.com/mlabs-haskell/plutip/tree/master/local-cluster
• #33
• https://github.com/mlabs-haskell/plutip/blob/master/docs/interactive-plutip.md
• should I seek ways to run tests on a remote?
• use flake? why, why not, how?

aleeusgr/plutip-example#10

contract execution example

• comment

{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE NumericUnderscores #-}

module Main (main) where

import Control.Monad.IO.Class (liftIO)
import Control.Monad.Reader (ReaderT (ReaderT), ask)
import Data.Default (def)
import Data.Monoid (Last (getLast))
import Data.Text.Lazy qualified as T
import ExampleContracts (ownValueToState)
import Test.Plutip.Config (
  PlutipConfig (extraConfig),
 )
import Test.Plutip.Contract (runContract)
import Test.Plutip.Internal.BotPlutusInterface.Wallet (
  BpiWallet,
  addSomeWallet,
  mkMainnetAddress,
  walletPkh,
 )
import Test.Plutip.Internal.Cluster.Extra.Types (
  ExtraConfig (ecSlotLength),
 )
import Test.Plutip.Internal.LocalCluster (
  startCluster,
  stopCluster,
 )
import Test.Plutip.Internal.Types (
  ClusterEnv,
  ExecutionResult (contractState, outcome),
  nodeSocket,
 )
import Test.Plutip.Tools.ChainIndex qualified as CI
import Text.Pretty.Simple (pShow)

main :: IO ()
main = do
  let slotLen = 1
      extraConf = def {ecSlotLength = slotLen}
      plutipConfig = def {extraConfig = extraConf}

      addSomeWalletWithCollateral funds =
        addSomeWallet (toAda 10 : funds)

  putStrLn "Starting cluster..."
  (st, _) <- startCluster plutipConfig $ do
    w <- addSomeWalletWithCollateral [toAda 100]
    liftIO $ putStrLn "Waiting for wallets to be funded..."
    CI.awaitWalletFunded w slotLen

    separate
    printWallet (w, 1)
    printNodeRelatedInfo

    separate
    res <- executeContract w ownValueToState
    printResult res

    separate

  putStrLn "Stopping cluster"

  stopCluster st
  where
    printNodeRelatedInfo = ReaderT $ \cEnv -> do
      putStrLn $ "Node socket: " <> show (nodeSocket cEnv)

    separate = liftIO $ putStrLn "\n------------\n"

    printWallet :: (BpiWallet, Int) -> ReaderT ClusterEnv IO ()
    printWallet (w, n) = liftIO $ do
      putStrLn $ "Wallet " ++ show n ++ " PKH: " ++ show (walletPkh w)
      putStrLn $ "Wallet " ++ show n ++ " mainnet address: " ++ show (mkMainnetAddress w)

    toAda = (* 1_000_000)

    executeContract wallet contract =
      ask >>= \cEnv -> runContract cEnv wallet contract

    printResult res = do
      liftIO . putStrLn $ "Execution outcome:\n" <> pShow' (outcome res)
      liftIO . putStrLn $
        "Contract state:\n"
          <> pShow' (getLast $ contractState res)

    pShow' :: Show a => a -> String
    pShow' = T.unpack . pShow

https://github.com/mlabs-haskell/plutip/blob/7f2d59abd911dd11310404863cdedb2886902ebf/contract-execution/Main.hs

Datum

Each UTxO locked at a script address will also have an associated datum. The script can choose to use the datum as part of the spending validation, or it can choose to ignore the datum if it is irrelevant.

Helios: Vitest example

https://github.com/lley154/helios-examples/tree/main/vitest

a test harness

• It makes sense to set up testing as server side node.js modules. (why)
• #33
• #37
• #11

Helios: get uplc

• comment 61 62
• test
  

  potential-robot/tests/mint-onchain-positive.test.js

  Lines 58 to 64 in 6b64083

  	// NFT minting script
  	const nftScript = await fs.readFile('./src/nft.hl', 'utf8');
  	const nftProgram = Program.new(nftScript);
  	nftProgram.parameters = {["TX_ID"] : utxos[0].txId.hex};
  	nftProgram.parameters = {["TX_IDX"] : utxos[0].utxoIdx};
  	const nftCompiledProgram = nftProgram.compile(optimize);
  	const nftMPH = nftCompiledProgram.mintingPolicyHash;

Alternative

littercoin minting module

when called via cli, passing parameters (see here), it returns a Json object with a status message and a cborHex (L142)

compare Data Structures

potential-robot/src/matching-keyhash.js

Lines 3 to 5 in 03873d8

	struct Datum {
	owner: PubKeyHash
	}

potential-robot/tests/lucid-matching-keyhash.test.ts

Lines 92 to 94 in 03873d8

	const datum = Data.to(
	new Constr(0, [new Constr(0, [paymentCredential?.hash!])]),
	);

• owner-only
• vesting
• always-succeeds

Next.js, npm, node, etc

what is the role of npm in this?
npm ~ cabal
npm | deno?

Next.js
routing system,
pages export components,
caching

https://www.youtube.com/watch?v=_w0Ikk4JY7U

tutorial

https://en.wikipedia.org/wiki/React_(software)