You interact with the Cardano blockchain through transactions. Your wallet software takes care of the common user tasks, yet for advanced endeavors you need the cardano-cli. However, it gets really cumbersome as transactions grow in complexity. Bash scripts tame the problem only for a while, because their limitation is the very thing they offer: Bash scripts automate repetitive tasks at the cost of flexibility.

The command line is a great tool, yet if I ever write more than 4 words on the command line I go crazy. The command line is, for me, a tool for quick queries not a work environment. Bash scripts are good to automate simple things and keep dependencies low, however I also go crazy when maintaining large bash scripts. Bash scripts keep you bound to the one dimensionality of the command line. Despite editing those scripts on an editor you must mark line breaks, and keep track of quoting your variables and input.

I want a tool that lets me craft my transactions, a powerful tool to interact with the cardano-node, which has all the features, does not get cumbersome as you increase the complexity of your tasks, and empowers you as a user.

I couldn’t find such a tool, thus I started building it myself. A text editable interface to create my transactions for the Cardano network. A tool that embraces the power of my text editor instead of the limitations of the command line.

I host a YouTube Channel called Ars magna for my Cardano related projects. If you doubt whether this project is for you, have a look at how it can change your workflow:

The videos are a show case of this project, yet as this project develops further, they naturally become obsolete. The documentation bellow is an up to date reference.

This project is a running experiment and in Alpha stage. Don’t rely on any of its functions or interfaces to be stable, because I’m still testing its user interface. Feedback is highly welcomed.

Warning aside, myself and other Cardano users believe this is an awesome way to interact with the Cardano blockchain, it frees you from the cumbersome CLI by offering you a declarative way to specify your transactions, without loosing fine grain control.

This project has received support from the Cardano community, it is a Catalyst Fund 7 & 9 funded projects and is a Plutus Pioneer Capstone challenge prize winner.

You need a running Cardano node post Vasil Hard-Fork you can connect to.

For Mainnet follow the standard guide https://docs.cardano.org/getting-started/installing-the-cardano-node

It manages the key generation for HD wallets

This package is the backend for Daedalus. It is another service that needs to run in the background, with it you have access to rich wallet functionalities.

This is the latest release. Install it and also the following packages.

This package is on MELPA. If you use use-package, get it directly

(use-package cardano-tx
  :commands (cardano-tx-new cardano-tx-cli-tip))

The file guix.scm provides a specification on all the package dependencies. Binaries from IOHK as well as the Emacs dependencies.

You can install this package with:

guix package -f guix.scm

Or you can enter a developer container with all necessary dependencies using:

guix shell -D -f guix.scm -C

There are some variables you need to configure.

;; Path to cli tool
(setq cardano-tx-cli-command "/full/path/to/the/cardano-cli")
;; Path to cardano-address binary
(setq cardano-tx-address-command (executable-find "cardano-address"))
;; Path to the running node socket
(setq cardano-tx-cli-node-socket "/full/path/to/the/testnet/socket")
;; These are the network arguments for the testnet
(setq cardano-tx-cli-network-args '("--testnet-magic" "1097911063"))
;; When connecting to mainnet use
;; (setq cardano-tx-cli-network-args '("--mainnet"))

;; This directory stores all your key pairs (verification & signing), it is your
;; wallet. It also holds your staking key. Make sure this folder exists, as this
;; tool will not create it. For wallet hygiene use separate directories for
;; mainnet and testnets. It also holds an SQLite database to administer known data.
(setq cardano-tx-db-keyring-dir (expand-file-name "~/cardano-wallet-keys/"))
;; In case you want to log the CLI commands used
(setq cardano-tx-log-level 'debug)

Although this package focuses on the low-level, high power interfaces for the cardano-cli and cardano-addresses, most of the time you just need a simple wallet to spend your ADA and keep track of that transaction history. To achieve that goal, this tool also integrates with cardano-wallet the middleware server that sits between your cardano-node and the Daedalus frontend.

cardano-wallet needs its own configuration to run the server that connects to your node and provides a local REST API to manage your wallet. Once you have configured it as specified on the official documentation, you only need to load the package and specify the API endpoint. Using use-package for example:

(use-package cardano-wallet
  :commands (cardano-wallet-balances cardano-wallet-helm-pick)
  :config
  (setq cardano-wallet-url "http://localhost:8090"))

Start by interactively querying the tip of the Blockchain. Use: M-x cardano-tx-cli-tip, you should see at the bottom of the screen on the mini-buffer the information about the tip.

At the time of writing it showed this:

epoch: 158
hash: 8b6c54c50355c945c2c9fcf354869651d60c129c86fd1be3b8c3d35273352569
slot: 38212104
block: 2941331
era: Alonzo
syncProgress: 100.00

To create new keys and their address use: M-x cardano-tx-address-new-key-files. It will prompt you how to name your new keys in your wallet. Type a name or many space separated names. This will populate the directory you defined in cardano-tx-db-keyring-dir, with the keys.

This means:

M-x cardano-tx-address-new-key-files RET first second third RET

will generated the following folder structure:

~/cardano-wallet-keys/
├── cardano.db
├── first.skey
├── first.vkey
├── second.skey
├── second.vkey
├── stake.skey
├── stake.vkey
├── third.skey
└── third.vkey

In the background it will create you default reward(staking) key and interactively ask you whether to create addresses with your new key files using that reward key or not. The addresses information and the keys are stored in the SQLite database cardano.db.

⚠ WARNING: Please keep in mind, that all keys are plain text files on your system. Thus, when working with “mainnet” ADA, make sure you take the necessary precautions to secure your files, work on an air gapped machine.

To create a staking key (under the name stake2) use the ELisp command:

(cardano-tx-address-new-key "stake2" t)

The name stake is the default name for the reward key, and created automatically. After creating additional reward keys, which you want to use in you addresses use cardano-tx-address-load, select the spending key type, confirm whether to watch the new address and which reward key you want to use. All key file and addresses are stored in the SQLite database in the cardano.db file.

The command cardano-tx-db-addresses opens a table view of all your know addresses. The keyboard shortcut c copies the address in the row your point is. w toggles whether that address is watched in your UTxO set. a lets you write a comment for that particular address.

You can also install cardano-addresses and let this tool help you manage your keys following the CIP-3 specification, and CIP-11.

The function cardano-tx-address-gen-recovery-phrase will assist you creating a mnemonic seed recovery phrase and save it on your cardano-tx-db-keyring-dir.

⚠ WARNING: Please keep in mind, that all keys and recovery phrases are plain text files on your system. Thus when working with “mainnet” ADA, make sure you take the necessary precautions to secure your files, work on air gapped machine.

The function cardano-tx-address-new-hd-key-files prompts for a derivation path for your key, you can still call this with many space separated paths. Following CIP-11 the path 1852H/1815H/0H/2/0 will generate the staking key.

If you generated some key files previous to using cardano.el or from previous versions of it, before its use of a SQLite database you need to register those keys to the database. The easiest way is using dired to mark the files you want to register and the interactively calling cardano-tx-db-dired-load-files. You can also register cardano native simple scripts (multisigs/timelocks) and Plutus script files.

To visualize the files registered in the database call the interactive function cardano-tx-db-typed-files. This opens a table view of all registered files. You may add annotations to each file. Annotations help you identify in the future their content more than the filename does. You can also open the files directly from this view.

cardano-tx-address-load calculates addresses from registered files and load them on the address database. Call it after registering new files.

To visualize addresses loaded into your database call cardano-tx-db-addresses. This opens a view with all registered addresses. You can toggle which ones to actively watch(query UTxO balance), copy the address to the keyboard or edit the annotation.

The goal is to directly create the transaction in your editor instead of using the CLI commands when crafting of the transaction.

To launch the editor call M-x cardano-tx-new. It will list all the UTxOs that you control on your wallet for you to spend. This might take a while as it is an expensive query for the cardano-node [fn:1]. Select one or many, you can still include more into your transaction during the edit process later on. A new buffer opens with the basic spending transaction template you can directly edit.

Have a look at the next annotated example. It is a larger than usual transaction(2 inputs - 4 outputs), because the goal of this tool is to demonstrate that it doesn’t get cumbersome as the transaction scope grows. It is a simple and standard yaml file. The structure reflects intuitively what the transaction itself is about. I’m sure you can understand it just by reading it.

# These are the inputs for the transaction.
inputs:
  - utxo: 4ea2254f4449af35b730b08f864663f1f0fd7a8a659e2fcf9a21fe891c2991d1#0
  - utxo: e0beb22982562e607019e6bb7f8cba200bba5f858c94bf6fd97ef4431ccb8be8#0

# Outputs are defined in the same way.
outputs:
  # A simple payment output to this address
  - address: addr_test1qr047xuayncdvsjdldy740a8l9hh6advdzex9nqtp4y3smtk2wgk4wl2rz04eaqmq9fnxhyn56az0c4d3unvcvg2yw4qqzhuv0
    amount:
      lovelace: 10000000

  # Payment to a Plutus script. The AlwaysSucceeds script
  - address: addr_test1wpnlxv2xv9a9ucvnvzqakwepzl9ltx7jzgm53av2e9ncv4sysemm8
    amount:
      lovelace: 15000000
    # You must include the datum. This tool calculates the hash for you.
    datum: [1, "the always succeeds contract", {"with a": "mixed type datum"}]

  # Payment to another Plutus script
  - address: addr_test1wzxfj3l2es945szu8wd6mm9jnkj7wze2zwtagkhdmn62gxqnvz87d
    amount:
      lovelace: 20000000
    # This script requires a typed datum, because the script input is a 2-tuple of ints
    # In this case the input is the path to a file that has the typed specification
    # of the datum
    datumfile: "plutus-data/tuple_ints(-5,6)"

  # ALWAYS think about your change address
  - address: addr_test1qpsfwsr4eqjfe49md9wpnyp3ws5emf4z3k6xqagvm880zgnk2wgk4wl2rz04eaqmq9fnxhyn56az0c4d3unvcvg2yw4qmkmv4t
    change: true # The cardano-cli balances it. Only lovelaces for now

Not only is it readable, you get the advantages of syntax highlight, indentation, auto-completion and many more editing tools from the editor. You can also write comments in between the lines, because yaml allows that. That is not possible within a bash script using long commands with line breaks, you only get to comment around the blocks of instructions.

When creating this transaction there are utility functions that help you with some input. For example:

• cardano-tx-helm-utxos Pick from utxos that are in your wallet for easy input.
• cardano-tx-address-pick Pick from all your registered addresses
• cardano-tx-available-balance Calculates, displays and loads to kill-ring the balance not yet committed to transaction outputs.

The Plutus scripts we send funds in this transaction are contracts/AlwaysSucceeds.plutus and contracts/list-in-range.plutus. The first takes any datum, the second takes a two element tuple to define a range. That’s why the datum needs to be a tuple, and why we need to use the typed version for the datum, because tuples are not available as JSON values.

In this repository you can find the datum file used for this example in the path plutus-data/tuple_ints(-5,6), and it has this content.

{"constructor":0,"fields":[{"int":-5},{"int":6}]}

To send the transaction just use shortcut C-c C-c or call M-x cardano-tx-edit-finish. That will build the transaction, calculate the fees, sign it, submit it, close the editing window and copy the transaction id to the clipboard for you to look for it in your favorite explorer.

This transaction has the id 20d4494be79b860b1085fc5b763840d74c25c5e2ba05daeed664b3e674301b00, and is on the Testnet.

The editor uses in general the build command to craft the transaction, which requires a change address. Unfortunately, that change address only balances the transaction with lovelaces and is a required field. However, if your change is exactly zero lovelaces the transaction would still work(see IntersectMBO/cardano-node#3041). You can thus use than function cardano-tx-available-balance to balance the transaction and once you try to build it extract the minimum fee value from the error message. Then put that value as an extra field on the transaction description:

fee: 189432

Re-balance your transaction outputs and try again, the change address although required will not show up on the crafted transaction, and the fee field is only a help to balance the transaction, as the build command does not use it.

Currently, it only makes sense to pay the minimum fee in Cardano. Yet, if it one day implements a market for fees, where a higher fee would help you get ahead on the mempool and prioritize your transaction you can set your fee. For that use the fee field, but delete the change address output. That will use the build-raw command where you specify the fee.

Minting tokens is again simple and doable with a single specification. Again, exemplifying with a rather large transaction, where I’ll mint two kinds of tokens: a fungible token with unconstrained minting policy and a NFT policy. Additionally, the NFT metadata will include its metadata.

Launch the editor with M-x cardano-tx-new, and pick some UTxOs to fund the mint transaction. It is a big transaction, don’t get overwhelmed by the forest they are only trees. Follow the comments, a lot is going on in this transaction. To help you write the minting specification typing mint followed by <TAB> will use yasnippet to load minting template specification.

inputs:
  - utxo: 4fae4f6e9c80d6c56476e083e9562a867ab7a6cd6be4e694d1f0b0e0b8d97eee#0

# Minting policies are characterized by the policy-id, here you can name them,
# and use that name throughout the transaction. The editor will then replace the
# name for the policy-id when creating the transaction.

mint:
  # This first policy(reward-tokens) only requires one witness to mint. You can mint
  # anytime you want as long as you have the key. I can use them as reward points.
  # I can keep minting to reward users.
  reward-tokens: # This is my first policy name
    policy: # Declare the policy. A single signature is enough
      type: sig
      keyHash: df5f1b9d24f0d6424dfb49eabfa7f96f7d75ac68b262cc0b0d49186d # fourth
    assets: # Here is the amount of assets to mint. I name each of the tokens
      gold: 100
      platinum: 50
  # This second policy are two NFTs. It honors XKCD, and mints NFTs that link to
  # a particular comic. The minting policy requires 2 witnesses and has a time lock
  # to ensure that no more assets are minted under this policy after the slot passed
  xkcd: # this is the policy name
    policy:
      type: all
      scripts:
        - type: sig
          keyHash: a6eb2a117cc8c5a26a7895eb03f3c88d3d2391e34e988883327b9893 # second
        - type: sig
          keyHash: 9bcde05606b1fbd5f5390b3ebbba0f523bddba5822027c856ebc336a # third
        - type: before
          slot: 41770500 # this is the time lock
    assets: # Minting two unique NFTs
      networking: 1
      frustration: 1

# You need to help the tool when using scripts by enumerating which witnesses
# need to sign the transaction. These are the keys on your wallet. I commented
# in the previous scripts which keyHash maps to which key
# You don't need this hint on normal spending, because it can infer which key owns which UTxO.
witness:
  - second
  - third
  - fourth

# For Mary Era Timelocked NFTs don't forget to match the validity interval, with
# the one on the time lock policy
validity-interval:
  invalid-hereafter: 41770500
  # invalid before:

# The metadata here allows to describe the NFTs. You can then see them on an explorer
metadata:
  721:
    xkcd: # policy name
      networking: # token name
        id: 1
        name: "Networking"
        description: "Our company is agile and lean with a focus on the long tail."
        image: ipfs://Qmbu8L59m5YHxo7kSCnfZa9DLSApyLFXTpbcJo6tx8vzzq
      frustration: # token name
        id: 2
        name: "Frustration"
        description: "Don't worry, I can do it in under a minute."
        image: ipfs://QmdunoNVjXe8aLFHvPqWdjNZmSfQBnrhb1pPwLcEAJcVUR

# Finally the 4 output. I distribute the newly minted tokens across multiple addresses
outputs:
  - address: addr_test1vzdumczkq6clh4048y9nawa6pafrhhd6tq3qyly9d67rx6sq3zpq7 # third-enterprise
    amount:
      xkcd: # policy name
        networking: 1 # token name
      reward-tokens: # other policy name
        gold: 40 # corresponding token name
      lovelace: 10000000

  - address: addr_test1qznwk2s30nyvtgn20z27kqlnezxn6gu3ud8f3zyrxfae3ymk2wgk4wl2rz04eaqmq9fnxhyn56az0c4d3unvcvg2yw4qt6aaad # second
    amount:
      reward-tokens:
        gold: 60
        platinum: 15
      lovelace: 15678910

  - address: addr_test1qpsfwsr4eqjfe49md9wpnyp3ws5emf4z3k6xqagvm880zgnk2wgk4wl2rz04eaqmq9fnxhyn56az0c4d3unvcvg2yw4qmkmv4t
    amount:
      xkcd:
        frustration: 1
      reward-tokens:
        platinum: 35
      lovelace: 52468413

  # ALWAYS think about your change address
  - address: addr_test1qpsfwsr4eqjfe49md9wpnyp3ws5emf4z3k6xqagvm880zgnk2wgk4wl2rz04eaqmq9fnxhyn56az0c4d3unvcvg2yw4qmkmv4t
    change: true

Have a look at the transaction on an testnet explorer: 9115ce93cc4afe074e79352de16671f9e85f77732406943ab05809180cdd282b

Notice that the token names are still described by human readable strings. The editor translates those names to hexadecimal values when creating the transaction as required by the cardano-node>=1.33.

The transaction to register and delegate at the same time looks like this:

input:
  - utxo: 83fa0a223783c9fb8a610433d75778c29945151a7bd7957e7c8c8289d7dc9e79#0

outputs:
  # ALWAYS think about your change address
  - address:  addr_test1qpsfwsr4eqjfe49md9wpnyp3ws5emf4z3k6xqagvm880zgnk2wgk4wl2rz04eaqmq9fnxhyn56az0c4d3unvcvg2yw4qmkmv4t
    change: true

certificates:
  # Standard certificates
  - registration:
      # vkey-file:  # optionally pick the staking verification key file
      # deregistration: true
  - delegation:
      pool: pool1hqatqegjcnsg8lj66ys2fe2zg8vl7hjsfy2yupcpnxxqucx8zgq
      # vkey-file:  # optionally pick the staking verification key file
  # Specify your particular certificate file
  # - file:

# You must sign with the stake key to authorize the certificate
witness:
  - stake

It is important to note, that you must register the stake address before you delegate your stake. If you are doing both actions in the same transaction, then make sure that the registration item is before the delegation item (like in this example) otherwise the transaction will fail. If you want to do this on separate transactions, it still holds to register before you delegate.

This sample transaction is also on the testnet under the txid: d77ecc5c249a7875fcae8a4dc0940b62a214d4fbcdc9e82a0ba4c38607b8ea2d

Withdrawing is again just another element of your transaction.

input:
  - utxo: 8bdfcfa7faa87f32c624700d1bec7fb0cd3af0ed3fb9e7a5e1121bc52433e645#0

outputs:
  # ALWAYS think about your change address
  - address:  addr_test1qpsfwsr4eqjfe49md9wpnyp3ws5emf4z3k6xqagvm880zgnk2wgk4wl2rz04eaqmq9fnxhyn56az0c4d3unvcvg2yw4qmkmv4t
    change: true

withdrawals:
  # Specify from which staking address you withdraw the rewards
  - address: stake_test1urpklgzqsh9yqz8pkyuxcw9dlszpe5flnxjtl55epla6ftqktdyfz
    amount:
      lovelace: 315716

# You must sign with the stake key because you spend from the staking address
witness:
  - stake

The function cardano-tx-rewards receives as input the staking addresses and helps you with the total amount in the rewards.

This sample transaction is also on the testnet under the txid: 81eaf7c476709599a1d2162104714cf5ab9b0b3d4b65287efcfd58483e8a3768

The Plutus script in this example has this validator script, and corresponds to the script in the file contracts/list-in-range.plutus.

{-# INLINABLE rangeContract #-}
rangeContract :: (Integer, Integer) -> [Integer] -> ScriptContext -> P.Bool
rangeContract (l,h) redeemer _ = P.all (\x -> l P.<= x P.&& (x P.<= h)) redeemer

data RangeContract
instance Scripts.ValidatorTypes RangeContract where
    type instance DatumType RangeContract = (Integer, Integer)
    type instance RedeemerType RangeContract = [Integer]

rangeContractInstance :: Scripts.TypedValidator RangeContract
rangeContractInstance = Scripts.mkTypedValidator @RangeContract
    $$(PlutusTx.compile [|| rangeContract ||])
    $$(PlutusTx.compile [|| wrap ||])
  where
    wrap = Scripts.wrapValidator @(Integer, Integer) @[Integer]

As you see we needed a two element tuple for the datum to define a range. The redeemer must be a list of “arbitrary length”, but all elements must be integers within the range defined by the datum. This is exercise 4.d of the Alonzo-testnet exercises.

One transaction that solves this constraint is:

inputs:
  # This is the UTxO that created in the previous section
  # Because it is a Plutus script. To unclock it we need to provide extra
  # information like the Plutus script, datum and redeemer
  - utxo: 20d4494be79b860b1085fc5b763840d74c25c5e2ba05daeed664b3e674301b00#3
    # path to the script file
    script-file: "contracts/list-in-range.plutus"
    # path to the typed datum
    datumfile: "plutus-data/tuple_ints(-5,6)"
    # I can directly specify a JSON value. List are JSON values and thus
    # can be directly parsed. There is no need to write the typed version in a file.
    redeemer: [2, -5, -1, 4, 0, 3, 1, 6, -4]

collateral: 20d4494be79b860b1085fc5b763840d74c25c5e2ba05daeed664b3e674301b00#1

outputs:
  # ALWAYS think about your change address
  - address:  addr_test1qpsfwsr4eqjfe49md9wpnyp3ws5emf4z3k6xqagvm880zgnk2wgk4wl2rz04eaqmq9fnxhyn56az0c4d3unvcvg2yw4qmkmv4t
    change: true

C-c C-c or calling M-x cardano-tx-edit-finish, builds and submits the transaction. In this case the transaction is 0e51486385a1d2cc811bf51fc27c73a609b87bfd8846955d1e67b358f44232e8 and you can find it on the testnet explorer.

That’s it. This tool reflects the transaction crafting with a User Interface, that is the transaction itself and takes care of all the details about parsing the input, signing and submitting.

The same scripts you used for minting policies are usable to secure funds. Those are simple multisig and timelock scripts. To create one of those scripts call the function cardano-tx-new-script. It will open an editor window where you can write the clauses of your script. The yasnippet shortcut ns expands into the clauses of a simple script. Simple scripts are recursive, thus you can go as deep as you want stating you spending clauses.

Press C-c C-c to save the script. This will convert the script from it’s YAML editing form to a JSON file and save it on your cardano-tx-db-keyring-dir for later use using the script hash as file name. Please understand that after that step you should never modify that file. If you need a new script with slight variations, make a new script and it to the database and keep that copy.

Visiting cardano-tx-db-typed-files you can see the newly created script. I advise you to also write a description of it using the annotation feature. Later you can call cardano-tx-address-load to calculate the address of this script and have it available for use.

If you installed the cardano-wallet the main entry point is the interactive function cardano-wallet-balances, which opens a buffer with a table showing the balances of all your registered wallets. To register a wallet call cardano-wallet-create, it will ask for the name of the wallet, a file containing the seed phrase(use the previous section for that), and a password to lock up your wallet. Once registered cardano-wallet will scan the blockchain for transactions pertaining your wallet, that takes a fair amount of time the first time, then it stays in watch mode and keeps synchronizing with the latest state of the blockchain.

cardano-wallet-helm-pick is the entry point to work with each of your wallets individually. Its menu lets start a payment transaction, list all addresses, look at the transaction history, and show a description of the wallet.

The file ouroboros.el contains a simple implementation of The Shelley Networking Protocol to connect to the node and query information. You can use it for the local state query mini-protocol, for example:

(setq sock (ouroboros-connect "/home/titan/test-cardano/dev-vasil/bp-vasil.socket" 9))
(ouroboros-local sock 'acquire 'tip)
(ouroboros-local sock 'query 'chain-point)
(ouroboros-local sock 'query 'block-no)
(ouroboros-local sock 'query 'system-start)
(ouroboros-local sock 'query 'hard-fork-eras)
(ouroboros-local sock 'query 'current-era)

(ouroboros-local sock 'query '(shelley epoch-no))
(ouroboros-local sock 'query `(shelley non-myopic-member-rewards
                                       ,(ouroboros-non-myopic-stake '(123456 456789133))))
(ouroboros-local sock 'query '(shelley current-params))
(ouroboros-local sock 'query '(shelley proposed-params))
(ouroboros-local sock 'query '(shelley stake-distribution))
(ouroboros-local sock 'query `(shelley utxo-by-address
                                 ,(ouroboros-address-query
                                   '("addr_test1vpsfwsr4eqjfe49md9wpnyp3ws5emf4z3k6xqagvm880zgs2k5jvj"
                                     "addr_test1zqeh2kmcf3wlp8jjlzve75mmvnmyac730p8j33zkxdawy7xn5qmqcmgt2t5gzpygzpr3y2y72d9ftuydut8qr8tqvqvs06lg42"))))
(ouroboros-local sock 'query '(shelley utxo-whole))
(->
 (ouroboros-local sock 'query '(shelley cbor-wrap epoch-no))
 (cbor-tag-content)
 (cbor->elisp))
(ouroboros-local sock 'query `(shelley filtered-delegations-and-reward-accounts
                                 ,(ouroboros-reward-addresses
                                   '("stake_test17r9cs7pxyf2nzlwg64fkf646kwq0mq9ucjlscefdthyj33sy8f0js"
                                     "stake_test1upm98yt2h04p386u7sdsz5entjf6dw38u2kc7fkvxy9z82s5f2lrh"))))
(ouroboros-local sock 'query '(shelley genesis-config))
(ouroboros-local sock 'query '(shelley reward-provenance))
(ouroboros-local sock 'query `(shelley utxo-by-tx-in
                                 ,(ouroboros-utxo
                                   '("c6a1c03c473753c932277634a39e8a3bacf4ae792eac174ab1e1b272d142db1f#0"))))

(ouroboros-local sock 'query '(shelley stake-pools))
(ouroboros-local sock 'query `(shelley stake-pool-params
                                 ,(cbor-tag-create
                                   :number 258
                                   :content ["13ab5c2838adaf649eb7e974779b705bb2b997c3c8132c3700c78dfe"
                                             "96788607f51dfaf3d115594e09cc6b75740035b8da05891995434268"])))
(ouroboros-local sock 'query '(shelley reward-info-pools))
(ouroboros-local sock 'release)
(ouroboros-local sock 'done)

I published a written document about all available queries in https://arsmagna.xyz/docs/network-lsq/. A short video series teaching you about the node communication and the local state query is available on YouTube. https://www.youtube.com/watch?v=rAWPudH55D4&list=PLwRUn-ZyfKJx2sj5hgJqL68KCTq7aSvkpG

This an awarded project of the Cardano Summit 2021 - Plutus Pioneer Capstone Challenge. You can read about it on the IOHK blog, and watch the interview with some of the winners. I hope it raises awareness of this tool and also to call attention to my Catalyst proposal to fund the further development of this tool.

If you are a Doom-Emacs user, you might realize that it becomes extra cumbersome to find the buffers from this tool. That is because of Doom’s philosophy of what makes an interesting buffer. You can tell Doom that these buffers are interesting by including the following code on your configuration file.

(add-hook! 'doom-real-buffer-functions
  (defun cardano-interesting-buffer (b)
    "Whether the current buffer's major-mode is a cardano mode."
    (with-current-buffer b
      (memq major-mode '(cardano-tx-db-addresses-mode
                         cardano-tx-db-files-mode
                         cardano-tx-mode
                         cardano-wallet-tx-log-mode)))))

[fn:1] Finding the UTxOs takes a while and thus your editor blocks during that time. Since the cardano-node=1.33 the UTxO set moved from RAM to Disk and that makes this query even slower.