plutigo

An implementation of Plutus in pure Go.

This package aims to only support Untyped Plutus Core because that is all that is needed for a full node. The other stuff like Typed Plutus Core and Plutus IR is for Plinth.

Features

• Complete Plutus Support: Implements Untyped Plutus Core (UPLC) evaluation
• Multi-Version Support: Compatible with Plutus V1, V2, V3, and initial Plutus V4 support
• Cost Model Integration: Automatic cost model selection based on Plutus version (Plutus V4 cost models are placeholders)
• High Performance: Optimized CEK machine implementation in pure Go
• Cryptographic Operations: Full BLS12-381 support using gnark-crypto
• Comprehensive Testing: 49.9% test coverage with fuzz testing and property-based testing

Supported CIPs

plutigo implements the following Cardano Improvement Proposals (CIPs) related to Plutus Core:

• CIP-0042: serialiseData builtin for CBOR serialization of Plutus Data
• CIP-0049: ECDSA and Schnorr signature verification builtins
• CIP-0058: Bitwise primitives for integers
• CIP-0085: Sums-of-products (constructor and case expressions)
• CIP-0091: Optimized builtin evaluation (no forced evaluation for saturated calls)
• CIP-0101: keccak_256 hash function
• CIP-0109: expModInteger for modular exponentiation
• CIP-0121: Integer to ByteString conversions
• CIP-0122: Logical operations on ByteString
• CIP-0123: Bitwise operations on ByteString
• CIP-0127: ripemd_160 hash function
• CIP-0132: dropList builtin
• CIP-0133: BLS12-381 multi-scalar multiplication
• CIP-0138: Array type and operations (lengthOfArray, listToArray, indexArray)
• CIP-0153: Mary-era Value builtins (insertCoin, lookupCoin, scaleValue, unionValue, valueContains)
• CIP-0156: multiIndexArray builtin for batch array indexing
• CIP-0381: BLS12-381 pairing operations

Testing and Conformance

All implemented CIPs include comprehensive conformance tests ensuring correct behavior and cost modeling.

Performance

plutigo is optimized for high-performance Plutus script evaluation:

Cryptographic Operations (Go 1.24, ARM64)

• SHA256: 96 ns/op
• Blake2b-256: 331 ns/op
• Ed25519 Verify: 251 μs/op
• ECDSA Verify: 379 μs/op
• BLS12-381 G1 Add: 3.5 μs/op
• BLS12-381 Pairing: 3.3 ms/op

Plutus Script Evaluation

Evaluates complex smart contracts (Uniswap, vesting, etc.) in milliseconds with accurate cost modeling.

Architecture

Core Components

• CEK Machine (cek/): Optimized evaluation engine with object pooling and memory-efficient state management
• Syntax Layer (syn/): Parser, pretty-printer, and AST transformations with De Bruijn conversion
• Builtin Functions (builtin/): Complete Plutus builtin function implementations
• Data Layer (data/): CBOR encoding/decoding for Plutus data types

Design Decisions

• Pure Go: No CGO dependencies for better portability and security
• Memory Safety: Comprehensive nil-pointer analysis and bounds checking
• Version Compatibility: Automatic cost model and builtin selection by Plutus version
• Testing First: Property-based testing and fuzzing ensure correctness

Usage

Install

go get github.com/blinklabs-io/plutigo

Example

package main

import (
	"fmt"

	"github.com/blinklabs-io/plutigo/cek"
	"github.com/blinklabs-io/plutigo/syn"
)

func main() {
	input := `
	(program 1.2.0
	  [
	    [
	      (builtin addInteger)
	      (con integer 1)
	    ]
	    (con integer 1)
	  ]
	)
	`

	pprogram, _ := syn.Parse(input)

	program, _ := syn.NameToDeBruijn(pprogram)

	// Create machine with Plutus V3 support
	// Third parameter is EvalContext (nil uses default cost model)
	machine := cek.NewMachine[syn.DeBruijn](program.Version, 200, nil)

	term, _ := machine.Run(program.Term)

	prettyTerm := syn.PrettyTerm[syn.DeBruijn](term)

	fmt.Println(prettyTerm) // Output: (con integer 2)
}

Plutus Version Support

plutigo supports all major Plutus protocol versions:

• Plutus V1 (1.0.0): Alonzo era - Basic builtin functions
• Plutus V2 (1.1.0): Vasil era - Additional crypto builtins
• Plutus V3 (1.2.0+): Chang+ era - Latest features and optimizations
• Plutus V4 (1.3.0+): Initial support with placeholder cost models

The library automatically selects appropriate cost models and builtin behavior based on the program version.

Development

Prerequisites

• Go 1.24+
• make

Setup

git clone https://github.com/blinklabs-io/plutigo.git
cd plutigo
go mod tidy

Testing

# Run all tests
make test

# Run benchmarks
make bench

# Run fuzz tests
make fuzz

Code Quality

The project maintains high code quality standards:

• Linting: Passes golangci-lint with zero issues
• Nil Safety: Passes nilaway static analysis
• Test Coverage: 49.9% coverage across all packages
• Fuzz Testing: Continuous fuzzing for parsing and evaluation

Contributing

We welcome contributions! Please see our Development Guide for setup, workflow, and contribution guidelines.

For organization-wide policies, see the Blink Labs Contributing Guide.