Category: Art Computing

Ethereum is a distributed computing system for writing and executing smart contracts. Inspired by Bitcoin, it’s currently in development with a planned late 2014 release date. The term “smart contracts” was coined around 1993 by computer scientist Nick Szabo to describe computer-readable code that replaces lawyer-readable code to describe agreements and obligations between people.

It’s a very literal take on Lawrence Lessig’s argument that “code is law”, a libertarian attempt to reduce the costs and uncertainty of having to trust human beings and interpret ambiguous human language, or possibly a dystopian replacement of rights and safeguards with binary logic.

Smart contracts can be used to implement smart property, physical goods governed by computer code, and Distributed Autonomous Organizations, which replace written constitutions with code running on Ethereum’s Blockchain.

This series of articles will look at applications of Ethereum to the production, exhibition, critique and institutions of art. Starting with digital art as smart property.

The sample code is written in Serpent, the high level Ethereum programming language, and is current as of Ethereum POC 5. It will be revised and tested for the release version of Ethereum.

You can learn more about Ethereum here and here. You can learn more about Serpent here and here.

Storing and Identifying Digital Art In Ethereum

There are three cases of digital art as smart property. The first is the conceptual or code art case, where the code of the contract itself is or contains the artwork. The second is the Ethereum storage case, where a small digital artwork is stored in the Ethereum datastore. The third is the stored identifier case, where only an identifier or proxy for the artwork is stored with the contract.

Conceptual and Code Art

Contracts that are themselves art are a simple case. They should store their owner’s Ethereum address and ensure that transactions initiating actions that only the owner should be able to perform come from that address.

Conceptual Art

As art is defined by its inutility, a contract that does nothing must be art. 😉

stop

Hot/Cold

A contract that does something, but nothing useful.

init:
    contract.storage[1000] = "hot"
    contract.storage[1001] = "cold"

code:
    // Make sure we have enough gas to run the contact
    if tx.value < tx.basefee * 100:
        // If not, stop
        stop

    // Swap
    temp = contract.storage[1000]
    contract.storage[1000] = contract.storage[1001]
    contract.storage[1001] = temp

Numbered Works

A simple generative work that creates a new, original piece for each request.

init:
    ARTWORK.NUMBER.INDEX = 1001 
    contract.storage[ARTWORK.NUMBER.INDEX] = 1

code:
    ARTWORK = "Work #"
    ARTWORK.NUMBER.INDEX = 1001
    // Make sure we have enough gas to run the contact
    if tx.value < tx.basefee * 400:
        // If not, stop
        stop

    // Get the number of the work to produce
    number = contract.storage[ARTWORK.NUMBER.INDEX]
    // Store the number to use for the next work
    contract.storage[ARTWORK.NUMBER.INDEX] = contract.storage[ARTWORK.NUMBER.INDEX] + 1
    // Return the work
    return([ARTWORK, number], 2)

Data Visualization

A simple customised generative work / data visualization. The output looks something like:

when assembled.

HEX = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
ARTWORK = [""]
ARTWORK.LENGTH = 10
ARTWORK.INSERT.END = 8

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 500:
    // If not, stop
    stop

// If there are enough arguments
// and the command to create the work is being given
if msg.datasize == 1 and msg.data[0] == "create":
    artwork = array(ARTWORK.LENGTH)
    artwork[0] = ARTWORK[0]
    artwork[1] = ARTWORK[1]
    artwork[2] = ARTWORK[2]
    artwork[9] = ARTWORK[3]
    // Copy the most significant hex bytes of the key as an html colour
    index = 0
    hash.bytes = msg.sender
    while index < 3:
        current.byte = hash.bytes % 256
        hash.bytes = hash.bytes / 256
        hi = HEX[current.byte / 16]
        lo = HEX[current.byte % 16]
        artwork[ARTWORK.INSERT.END - (index * 2)] = lo
        artwork[ARTWORK.INSERT.END - (index * 2) + 1] = hi
        index = index + 1
    return(artwork, ARTWORK.LENGTH)
// Otherwise
else:
    // Logical false for failure
    return(0)

Stored Art

Digital art can be stored in a contract’s bytecodes or permanent storage rather than generated by the contract’s code.

A Stored Image

ARTWORK = ['P1\n32 32\n00000000000000010000000', '00000000000000000000000010000000', '000000000000000\n0000000001000000', '00000000000000000000000001000000', '0000000000000000000000\n001100000', '00000000000000000000001100001010', '00001100001000000000100000000\n00', '01011000010000000000100000000000', '01111000100000000001000000000001', '1111\n000100000000001000000000011', '11110110000000000010000000001111', '11100010000\n00000000000000011111', '11000000000000000010000001111111', '110000001000000000\n1000001111111', '11000000000000000000000000111111', '1110000001000000000000000\n000011', '11111000000000000000100000000001', '11111100000100000000000000000111', '\n1111110000000000000010000000011', '11111100000100000000010000001111', '1111000\n000010000000000000000111', '11110000000000000000000100001111', '10000000000100\n00000000000001111', '10000000000010000000000001111100', '000000000001000000000\n0000011100', '00000000000100000000000000101000', '0000000000000000000000000000\n010', '10000000010100000000000000000000', '01010010100000000000000000000000', '000\n0110000000000000000000000000', '00000100000000000000000000000000', '0000010000\n000000000000000000000', '00000010000000000000000']

ARTWORK.LENGTH = 33

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 1000:
    // If not, stop
    stop

// If there are enough arguments
// and the command to show the work is being given
if msg.datasize == 1 and msg.data[0] == "exhibit":
    // Just return the artwork
    return(ARTWORK, ARTWORK.LENGTH)
// Otherwise
else:
    // Logical false for failure
    return(0)

Identifiers For Digital Art

Where a work of digital art will not fit in the blockchain a more compact identifier must be stored in the contract and used to refer to the work instead.

Ideally a method for identifying unique instances of a digital artwork will be:

• Stable. The identifier should be usable for decades. Web URLs for example can change or become inaccessible as services change how they serve content or go out of business.
• Verifiable. The identifier should be usable as a way of verifying that a resource is the one it refers to. Cryptographic hashes for example will not work with digital images that have been resized or GPS co-ordinates that differ even fractionally.
• Amendable. Where stability fails or a change in ownership requires a change in identifier, it should be possible to update the identifier in a trusted and verifiable way.
• Sufficient. The information required to identify the resource should be usable directly from the contract rather than requiring external information to complete it.
• Private. An identifier should leak as little information about the owner of the resource as possible. For example GPS co-ordinates or street addresses, while stable, do locate the resource and possibly its owner. Storing only the cryptographic hash of an identifier can mitigate this.

Some of these criteria clash and therefore any given method of identification must trade them off against each other. For example being private and verifiable, or stable and amendable.

For artworks to interact with smart contracts we need a way of identifying them in those contracts.Where a digital artwork is too large or complex to keep in the contract’s code or storage, a proxy or compact identifier that refers to the must be used.

The following identifiers have various strengths and weaknesses. We’ll use some of them in the next section.

URL

A URL, such as a web site address, is a clear public identifier. It lacks privacy and is only as stable as the service hosting it, but has the advantage of being unique. To add a veneer of privacy, only the cryptographic hash of the URL can be stored by the contract and this can be checked against the hash of a URL by anyone who wishes to check whether it is the instance of the work referred to by the contract.

For example the url:

http://OFFLINEZIP.wpsho/wp-content/uploads/2012/10/applied_aesthetics-824×1024.png

has the SHA256 hash:

6a1811d79b46ab9e43f449beb9838e21dc5865d293e3dfb9b4ba508c7261b915

Never use a link shortening service or a consumer third party hosting service for work represented as URLs, such services are likely to go out of business or change their URL structure, rendering identifiers using them useless. When using your own site for hosting work make sure both to both keep your domain name registered and the server running and to make provisions for them to be maintained when you are no longer able or willing to do so.

File Hash

Producing a cryptographic hash of a work contained in or represented by a file is simple and uniquely identifies the data contained by the file (although any copies of the file will have the same hash). It is better to hash the contents of the file rather than the file itself: an image that has the same pixel values as a PNG or a GIF will have a very different structure on disk in each of those formats. Likewise the full-size or full-quality version of the contents of the file should be hashed rather than a thumbnail or a lossy version.

Git Repository Commit Hash

Modern decentralised version control systems use cryptographic hashes to identify commits. Hashes can identify version of works in a series within a version control repository, although they are best accompanied by a URL or other identifier for the repository.

Serial Number or UUID

A serial number or unique identifier embedded in the work’s filename or metadata can be used to identify it. Visible watermarks are the mark of the amateur, and steganographic watermarks are easily defeated.

Cryptographic Signing

When producing editions of a digital work, each can be signed by the artist to identify it as authorised.

Name

When all else fails, a unique name and description for a work is a useful identifier.

Art As Smart Propery

A Simple Owned Work

OWNER = 0x7c8999dc9a822c1f0df42023113edb4fdd543266

// Get the owner Ethereum address
return(OWNER)

A Simple Owned Work That Confirms Ownership

OWNER = 0x7c8999dc9a822c1f0df42023113edb4fdd543266

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 100:
    // If not, stop
    stop

// If the Ethereum address sent matches the owner
if msg.data[0] == OWNER:
    // Return true
    return(1)
// Otherwise
else:
    // Return false
    return(0)

A Simple Owned Stored Work

OWNER = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6 // Artist initially
WORK = "The art happens here."

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 200:
    // If not, stop
    stop

// If there are enough arguments
// and the command to return the owner address is given
if msg.datasize == 1 and msg.data[0] == "owner":
    // Return the owning Ethereum address
    return(OWNER)
// If there are enough arguments
// and the command to return the artwork is given
if msg.datasize == 1 and msg.data[0] == "work":
    // Return the work
    return(WORK)
// Otherwise
else:
    // Return logical failure
    return(0)

Simple Transferable Stored Work

init:
    ARTIST = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6
    OWNER = 1001
    // Initialize the owner to be the artist
    contract.storage[OWNER] = ARTIST
code:
    OWNER = 1001
    ARTWORK = "The art happens here."
    // Make sure we have enough gas to run the contact
    if tx.value < tx.basefee * 200:
        // If not, stop
        stop

    // If the message is from the current owner
    // and there are enough arguments
    // and the command to transfer is being given
    if msg.sender == contract.storage[OWNER] and msg.datasize == 2 and msg.data[0] == "transfer":
        // Transfer it to a new owner
        contract.storage[OWNER] = msg.data[1]
        return(1)
    // If there are enough arguments
    // and the command to show the work is being given
    else if (msg.datasize == 1):
        // Just return the artwork
        return(ARTWORK)
    // Otherwise
    else:
        // Logical false for failure
        return(0)

An Ownership Registry For Digital Art

if tx.value < tx.basefee * 200:     // If not enough gas, stop     stop // If data was provided, it won't overwrite the code, and the artwork is unregistered if msg.datasize == 1 and msg.data[0] > 1000 and contract.storage[msg.data[0]] == 0:
    // Set the owner to be the sender
    contract.storage[msg.data[0]] = msg.sender
    return(1)
else:
    // Do nothing
    return(0)

A Hash-based Ownership Registry For Specific Instances Digital Art

This is a registry for ownership of artworks at specific urls. Artworks are identified by the hash of their file contents and by the hash of their url. Owners are identified by Ethereum address.

if tx.value < tx.basefee * 200:
    // If not, stop
    stop

// If registration is being requested
if msg.datasize == 3 and msg.data[0] == "register":
    // If the url/work combination has not been claimed
    if ! contract.storage[msg.data[1]]:
        // Set the owner to be the provided Ethereum address
        contract.storage[msg.data[1]] = msg.sender
        // Store the artwork hash next to the url ownership information
        contract.storage[msg.data[1] + 1] = msg.data[2]
        // return success
        return(1)
    // If the sender was trying to overwrite a work they do not own
    else:
        // They cannot set it, so return failure
        return(0)
// If ownership confirmation is being requested
// Confirm that the work and url hashes match
else if msg.datasize == 4 and msg.data[0] == "confirm":
    // Check the provided hashes against the stored work and url hashes
    return((contract.storage[msg.data[2]] == msg.data[1]) and (contract.storage[msg.data[2] + 1] == msg.data[3]))
// If no action was specified
else:
    // Otherwise do nothing
    return(0)

Authenticating Art In Ethereum

Authentication, like ownership, is related to identity and contract law.

A Simple Certificate Of Authenticity For Digital Art

ARTIST = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6
ARTWORK.HASH = 0x76bba376ea574e63ab357b2374d1cee5aa77d24db38115e3824c5cc4f443d5f7

return((msg.data[0] == ARTIST) and (msg.data[1] == ARTWORK.HASH))

ARTIST = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6
WORK.HASH = 0x76bba376ea574e63ab357b2374d1cee5aa77d24db38115e3824c5cc4f443d5f7
URL.HASH = 0xa005b1625af0b6ee080dafb904c4505ad285764071ee45a8786159bd1a282634

// If there are enough arguments
if msg.datasize == 2:
    // Check the provided hashes against the stored work and url hashes
    return((msg.data[0] == WORK.HASH) and (msg.data[1] == URL.HASH))
// Otherwise
else:
    // Do nothing
    stop

Catalogue Raisonné For Digital Artists

ARTIST = 0x8802b7f0bfa5e9f5825f2fc708e1ad00d2c2b5d6

// Make sure we have enough gas to run the contact
if tx.value < tx.basefee * 200:
    // If not, stop
    stop
    
// If the message is from the artist
if msg.datasize == 1 and msg.sender == ARTIST:
    // Add the work to the catalog
    contract.storage[msg.data[0]] = 1
    return(1)
// check inclusion
else if msg.datasize == 1:
    // Check whether the artwork is in the catalog
    return(contract.storage[msg.data[0]])
// Otherwise
else:
    return(0)