Craftware Docs
  • What is Craftware?
    • Game Samples using Craftware
  • ❗Getting Started
  • SDKs
    • Unity3D SDK Guide
    • Golang SDK Guide
  • Blockchain Elements
    • Smart Contracts
    • ICraftableIn Library
  • 🎮Game Content
    • Game Assets
      • Resources
        • Create a resource
        • Retrieve Resources in Game
      • Currencies
      • Items
      • Properties
      • Export Assets Data
      • Import Assets Data
    • Crafting
      • Crafting Rule
  • 🤝Onchain Interoperability
    • Authentication
      • Wallet Binding
      • Wallet Session Authentication
      • Setting Up Wallet Authentication
    • Ports Protocol
      • Export Protocol
      • Import Protocol
    • Backward Compatibility
    • Crafting Protocol
      • Craftable Token
        • Definition Metadata
        • Craftable Input Token
        • Craftable Output Token
      • Crafting Rule Contract
        • Definition Metadata
      • Crafting Rule No-code Designer
  • âš™ī¸Admin
    • Account Settings
      • Account
      • Users
      • API Keys
      • Plan
      • Config
    • Security
    • Terms of Service
    • Privacy Policy
Powered by GitBook
On this page
  • What is Crafting?
  • What is the Goal?
  • Architecture Overview
  • Definition Metadata & Web apps
  • Helping games create crafting rules

Was this helpful?

  1. Onchain Interoperability

Crafting Protocol

Combining on-chain tokens from many games to create on-chain tokens for other games.

PreviousBackward CompatibilityNextCraftable Token

Last updated 1 year ago

Was this helpful?

The Crafting Protocol is a set of abstract contracts and interfaces that build around and interact with tokens strictly.

What is Crafting?

Crafting is the missing piece of cross-game collaboration and utilizing game tokens. The Crafting Protocol is a set of specifications, Smart Contracts, and interfaces that allow web3 games to join hands and collaborate on complex token swap deals. With the Crafting protocol, we aim to create accessible and scalable agreements on exchanging a set of tokens from many games to other tokens from other games.

What is the Goal?

In this protocol, we are targeting three stakeholders:

  • Input Web3 Tokens: Web3 Games with tokens to offload (Ingredients)

  • Output Web3 Tokens: Web3 Games that want to craft their tokens from other games (Outputs)

  • Players who want to engage in the play-to-earn scheme hoping to find a value in the tokens of game 1 by crafting corresponding tokens in game 2.

The motivations for these 3 parties can vary widely based on the use case.

So, we aim to provide a service that allows games to collaborate on defining a new crafting rule with

  • Ingredients: a set of tokens with diverse balances, attributes, and origin contracts.

  • Outputs: another set of such tokens from other games and contracts.

  • Mapping Method: an immutable, generic, scalable, accessible, and efficient manner to define the output balances and attributes based on the ingredients the player provides. We the quantities of interest are:

    • Attributes: A set of unique values that associate with a token ID. ex: sword length, material, ...

    • Balances: The quantity of such tokens. ex: 3 swords with the same attributes.

    So, the mapping rule takes as input the balances and attributes of ingredients and mints tokens with corresponding balances and attributes. for ex:

mapping.sol
...
function rule( Bag memory inBag, ItemAttributes[] memory inAttributes) {
    ...
    // sandwich type:
    // sweet falafel and not hummus => falafel icecream sandwich
    if (falafelAttributes.attributes[0] == 1 && condiment.class != 2) {
      outAttributes[0].attributes[0] = 3;
    } else if ( ... ) {
        ...
    }
}
...

In this system, all partner games - posing as both ingredients and outputs - need to approve said crafting rule to authorize it to:

  • transfer player ingredient tokens

  • mint output tokens based on the immutable rules

Finally, the system should adhere to the security requirements that prevent members in the system of abusing power, trust, and timing problems.

Architecture Overview

Our system is an end-to-end suite of abstract contracts and interfaces from which any ERC1155 can be inherited. During the development of these components, we aimed to allow the most flexibility to games to define how their own tokens operate, while asking for minimal functions to manipulate and represent some of the entry points.

At the heart of the Crafting Protocol is our Abstract Smart Contracts and Interfaces

Crafting Rule

The Crafting Rule is an abstract contract that implements all the functions required to accept ingredients in a standard format, and mint or transfer outputs. The user will care about two main functions once a crafting rule is deployed

Crafting Rule Contract

Craftable Input

ex: contract MyFalafel is CraftableIn, ... {

A key constraint for the input tokens is that they must implement on-chain attribute storage.

The Craftable Input extension to any token contract will be completely transparent to the user.

On the other hand, Game Token Developers must implement the following functions:

Craftable Output

Similar to Craftable input, but rather than constraining the attributes to be on chain, they can be stored anywhere.

The developers must implement the following functions before deploying:

  • CraftableOut._storeTemplateData( ... ) : A function that takes in the attributes for a template to be added and the template ID. This function allows the designer to be flexible in how to store the template data. For example, some would store them in a mapping fashion on-chain, while others will point to pre-hosted off-chain metadata URIs.

Definition Metadata & Web apps

One of the requirements of the protocol is to be accessible to users (players and game managers). This requires an easy way for all parties to lookup what tokens does this ERC1155 contract provide and what are their attributes. While this is a relevant question for business applications, it is not necessary to store the "meaning" of attributes[0] as "length of the sword" on-chain for scalability, generalizability, and storage efficiency. Similarly to how OpenSea requires a metadata file to make sense of the attributes of a certain token, we require a definition metadata file to make sense of the Craftable tokens.

Using the Craftable abstract contracts -as mentioned- all tokens attributes are defined in an ordered list. The meaning of each attribute of the list is stored in a metadata file hosted somewhere accessible to parties but not necessarily on-chain. We call these descriptive files as Definitions.

Definitions are small JSON files that encapsulate the what matters for Games and Players.

For illustration purposes, this is the definition of a falafel ERC1155 Craftable token.

falafel_definition.json
{
  "name": "Falafel",
  "classes": [
    // list of the token "classes" supported
    // here just one class exists, which is Falafel
  
    {
      // definition of the Falafel "class"
      "name": "Falafel",                  // class name
      "class": 1,                         // class ID
      "attributes": [
        // list of attributes
        // order in contract must be honored
        {
          // attribute 1 definition
          "name": "taste",                // attribute name
          "type": "categorical",          // attribute type (for evaluation purposes)
          
          // categorical attributes have different options
          "values": [
            { "name": "sweet", "value": 1 },
            { "name": "hot", "value": 3 },
            { "name": "salty", "value": 2 },
            { "name": "sour", "value": 4 },
            { "name": "bitter", "value": 5 }
          ]
        },
        {
          // attribute 2 definition
          "name": "size",
          "type": "numerical",
          
          // numerical attributes have min, max, 
          // and resolution (number of possible values)
          "min": 0.0,
          "max": 100.0,
          "res": 32
        }
      ]
    }
  ]
}

Helping games create crafting rules

This tool will help you:

  • search and display craftable input and output contracts others deployed.

  • select from many methods of generating the crafting rule and mapping the attribute combinations of input tokens to output tokens. For example, we provide a spreadsheet approach, filters approach, etc...

  • preview the Crafting smart contract and deploy it.

This is just a basic example. To find more details about the types in the parameters for the function, the representation of attributes, ... Check

which takes lists of tokens the user owns from the ingredient contracts, maps the balances and attributes, and mints the tokens to the user.

We designed crafting to be reversible. At any time that you want to redeem the ingredients back to your wallet, call redeem .

The game developers need to worry about three functions before deploying a crafting rule to enforce a standard method to interact with the contract

: To make sure the user inputs the tokens in a specified and agreed order.

: To make sure the user inputs the tokens in a specified and agreed order.

: The central function of the contract. In this function you write the mapping code to compute output attributes and balances from input attributes and balances.

The Craftable Input is an abstract contract with a set of functions and logic units that augment existing tokens to be consumable by the.

which must return the attribute value at a specific index as ordered in the file hosted for the token. (More about that in ).

(optional) function tokenURI( ... ): an optional function to generate a URI for the token in alignment with the

Before moving forwards, we need to introduce the concept of a template. Tokens having the same attribute values are said to have the same template. For each template is associated an ID. (ex: Token #1 (length=2, width=3) and Token #2 (length=2, width=3) have the same template). Templates are important to optimize the storage of attribute lists for similar tokens.

CraftableOut._templateURI( ... ) : Given a template ID, returns the URI pointing to the Formatted JSON file containing the attributes and values. It is flexible for designers to point to external URIs if attributes are handled off-chain or for on-chain attribute storage.

Because we aim to make crafting rules accessible to all games, we offer a.

🤝
â„šī¸
ERC1155
ERC1155
Crafting Rule Contract.
ERC1155
ERC1155
Crafting Rule
OpenSea Metadata standards.
OpenSea Metadata
Data URLs
no-code tool
Definition
Craftable Input Token
CraftableIn.attributes( ... ):
CraftingRule.craft( ... )
CraftingRule.redeem( ... )
CraftingRule._inputItemOrderValid( ... )
CraftingRule._outputItemOrderValid( ... )
CraftingRule.rule( ... )