Andrea Franz

NFT built-in Swap Market with gasless listing

Mon, 22 Nov 2021 00:00:00 +0000

More than a year ago I was working on a Token Redeem dApp for the Keycard Hardware Wallet that supported both ERC20 and ERC721 tokens. While working on that I had the idea of adding some gamification to a standard ERC721 contract: something similar to what I used to do when I was younger, swapping NBA cards with friends to collect all the players of my favourite team.

If we think of the full collection of those cards as an ERC721 collection, the players’ team can be thought as a trait type of that NFT.

There are many platforms that allow to buy and sell NFTs, but what I wanted to add was a way to be able to list my cards without paying gas, and to swap them atomically with other cards with some specific traits I like, to include them in my collection.

If all or some of the traits are on chain, it’s easy to implement a swap with some kind of trait validation. And anyone can list their cards simply using a signature, following the same pattern as the one used in the EIP-2612 permit function.

Moreover, we can add some swap rules in the EIP-721 message that validate the swap based on the traits I like.

Example:

Alice has card 1 and 2 both with trait A and she wants a card with trait B OR C.
She signs a message that says: “card 1 can be swapped with any card with trait B OR C”.
The message and signature can be saved on a centralized server or shared by Alice with friends.
Bob receives the signature and sends it with a transaction to the contract specifying the id of the cards he wants to swap.
The contract checks if Bob’s card is either a B or C, and swap the cards atomically.

The rule can be a simple bitstring like:

0001 (swappable only with trait A)
0011 (swappable only with trait A or B)
1011 (swappable only with trait A, B, or D)

I like this idea because it adds more dynamics for collectors, even if it can be very specific to each project and cannot really be used as a standard. Nevertheless, I decided to start a new project to test it, together with my friend and favourite artist Royb.

For both of us this has been a side project, and therefore it took many months to be completed, but in this long journey we learnt a lot and finally we are happy to announce that this new idea will be launched soon!

CyberTarot NFT

When he joined the team, Royb was working on some artwork inspired by the Tarot Major Arcana cards, so we decided to build our project along the same lines as the Tarot Cards Games.

This initial concept was conceived with special focus on the Art itself and on the Swap Market in order to convey some initial level of gamification, while leaving the development of a full game for the future, hopefully by sponsoring people from the community to contribute to it.

We named it CyberTarot, and Royb started producing some amazing work, with more than 450 drawings that together built a collection of 580 unique traits and 10K CyberTarot Minor Arcana.

Each one of these Minor Arcana, amongst its many traits, has a rank and a suit based on the token id. And since the token id is available to the Swap Market, they can be used as swap rules as described above. By swapping cards, collectors will be able to create mini decks with cards ranked from 0 to 9, or royal mini decks if they follow the same suit.

The second phase of the project will be the deployment of the 22 fractionalized Major Arcana, whose shares can be minted only by owning a mini deck.

We hope that this project is well received by the NFT community. Our goal has been to make it innovative and different from the usual PFPs, by adding much more diversification and value to the art, as well as by introducing gamification dynamics that we are really excited to see in action soon.

If this project has gotten you excited like we are, please share this post and follow/share our CyberTarotNFT Twitter account.

If you want to collaborate and help build a community around the CyberTarot, please slide in my DM :).

happy hacking.

Signed request query string with Elixir

Mon, 08 May 2017 00:00:00 +0000

SignedRequest is a simple Elixir module created to sign request query strings using HMAC.

Let’s say app-1 generates a page with a list of images dynamically generated by app-2. Something like:

<ul>
  <li>
    <img src="http://app-2.local/generate-image?type=png&size=200">
  <li>
  ...
</ul>

The URL of that image is viewable by users, this means that someone can maliciously open that link and change the size parameter to a big number, making app-2 blow up.

Instead of adding validations for each parameter we receive in the query string, we can just sign the request so that app-2 knows that the url has been generated by app-1.

Both apps share the same secret key:

config :signed_request, :secret_key, "SECRET-KEY-SHARED-BY-BOTH-APPS"

app-1 uses SignedRequest.SignedURI to sign the query string:

query = %{type: :png, size: 200}
query_string = SignedRequest.SignedURI.encode_query(query)

The generated query string contains now a sig parameter:

"sig=addebd2454bded3770f09fe7bcd979e41b108385d80e02771734ab37e8b25641&size=200&type=png"

app-2 can now decode the query string and validate the signature:

case SignedRequest.SignedURI.decode_query(query) do
  {:ok, query} ->
    do_something(query)
  {:error, :invalid_hmac} ->
    render_404()
end

Build and restart your Go web app with Fresh

Wed, 15 Jan 2014 00:00:00 +0000

Fresh is a command line tool that builds and (re)starts your web application everytime you save a Go file.

I usually use tests when I add/change some features in my application, so I don’t need to refresh the browser to check if everything works. But when I change simple things, or maybe some templates, I need to stop the server, build and restart. It’s not a big deal since go build is really fast, but I wanted to automate this process with Fresh.

Instead of running the application directly, I run fresh inside the app folder. Every time I create/modify/delete a file, Fresh runs go build and restarts the application. If the build command returns an error, it will log the error message in the tmp folder. If the framework you are using supports Fresh, it can show that error in the browser.

Traffic already supports it. If you run a Traffic app with Fresh, Traffic automatically add a Middleware that shows the build errors if an error log file exists.

Anyway Fresh is not part of Traffic, and you can use it with any other framework that supports some kind of middleware.

In the _example folder there is an example app using Martini where I created a simple middleware that uses some functions from github.com/gravityblast/fresh/runner/runnerutils. I made the same for gocraft/web.

In the gravityblast-martini folder there is another example using a modified version of Martini that already uses the runner lib.

Check the repository on Github for more informations, and feel free to send me a pull request.

ActiveMusicbrainz - How to use the Musicbrainz database from Ruby

Mon, 09 Dec 2013 00:00:00 +0000

If you need to use Ruby to access the Musicbrainz database you can use ActiveMusicbrainz. ActiveMusicbrainz is a library based on ActiveRecord that automatically creates one model for each Musicbrainz table and defines the main associations between them.

If you want to use it in a rails application, add the gem dependency to the Gemfile:

gem 'active_musicbrainz'

You need to initialize the library after connecting to the database. In rails you can add the following line inside a file in your initializers folder:

ActiveMusicbrainz.init

The line above will initialize all the models, one for each table, even if they are not defined in the library.

Now you can start playing with the musicbrainz database. You can use the by_gid method on all the Models that have a gid column, which defines the MBID of that resource:

artist = ActiveMusicbrainz::Model::Artist.by_gid '9a709693-b4f8-4da9-8cc1-038c911a61be'
=> #<ActiveMusicbrainz::Model::Artist id: 24146, gid: "9a709693-b4f8-4da9-8cc1-038c911a61be", name: "Bonobo", sort_name: "Bonobo", begin_date_year: 1976, begin_date_month: 3, begin_date_day: 30, end_date_year: nil, end_date_month: nil, end_date_day: nil, type: 1, area: 221, gender: 1, comment: "UK electro artist Simon Green", edits_pending: 0, last_updated: "2013-05-13 11:00:09", ended: false, begin_area: nil, end_area: nil>

artist.name
=> "Bonobo"

artist.release_groups.first.type
=> #<ActiveMusicbrainz::Model::ReleaseGroupPrimaryType id: 1, name: "Album">

artist.release_groups.each{|r| puts r.name }
Black Sands
Dial 'M' for Monkey
Scuba EP
Flutter
Pick Up
Terrapin
Eyesdown
...

artist.release_groups.first.releases.first.mediums
=> [#<ActiveMusicbrainz::Model::Medium id: 654199, release: 654199, position: 1, format: 1, name: nil, edits_pending: 0, last_updated: "2012-01-15 13:46:18", track_count: 12>]

artist.release_groups.first.releases.first.mediums.first.tracks.each{|t| puts t.name}
Prelude
Kiara
Kong
Eyesdown
...

artist.release_groups.first.releases.first.mediums.first.format
=> #<ActiveMusicbrainz::Model::MediumFormat id: 1, name: "CD", parent: nil, child_order: 0, year: 1982, has_discids: true>

Check out the project on Github for more info.

How to deploy Go with Traffic on Heroku

Thu, 05 Dec 2013 00:00:00 +0000

It’s really easy to deploy a Go application based on the Traffic web framework on Heroku. Let’s start with a simple example.

First of all, we need a simple Traffic app:

mkdir hello
cd hello

Create the main.go file with the following content:

package main

import (
  "github.com/gravityblast/traffic"
)

func hello(w traffic.ResponseWriter, r *traffic.Request) {
  w.WriteText("Hello World")
}

func main() {
  r := traffic.New()
  r.Get("/", hello)
  r.Run()
}

Now you should be able to run the example with:

go run main.go

Check http://localhost:7000.

Now we need to create a new Heroku app based on the Go Heroku Buildpack. You can red more about that on this tutorial, but it’s very easy, we just need a couple of files and commands.

Create the .godir file with the app name inside:

echo 'hello' > .godir

Now we need a file called Procfile with some configuration for Traffic:

web: TRAFFIC_PORT=$PORT TRAFFIC_ENV=production TRAFFIC_HOST=0.0.0.0 hello

We set 3 environment variables before calling our executable.

TRAFFIC_PORT

By default Traffic runs on port 7000. You can change the port in your code using traffic.SetPort(3000) or just using the TRAFFIC_PORT variable.

TRAFFIC_ENV

By default Traffic runs in development mode. This means that it adds some useful middleware for development like the ShowErrorsMiddleware, but you don’t want to add them in production. To run Traffic in production mode, just set TRAFFIC_ENV=production. If you need to serve static files like css or images, you need to use the StaticMiddleware, which is automatically loaded in development mode but not in production.

To enable it in production, add the following code:

if traffic.Env() == "production" {
  r.Use(traffic.NewStaticMiddleware(traffic.PublicPath()))
}

TRAFFIC_HOST

By default Traffic starts on 127.0.0.1:7000, and it’s visible only from your local machine. To be able to see your application in production you need to bind it to 0.0.0.0.

Now we just need to initialize our git repository, create the heroku app, and deploy it:

git init
git add .
git commit -am "initial commit"

heroku create -b https://github.com/kr/heroku-buildpack-go.git

git push heroku master

Check if it works:

heroku open

musiXmatch API library for NodeJS

Sun, 12 Feb 2012 00:00:00 +0000

I’ve just published my first NPM package, and it’s called musixmatch. With this library you can easily use the musiXmatch API with a few lines of javascript. Install it with NPM:

npm install -g musixmatch

And here an example:

var util  = require("util");
var mXm   = require("musixmatch");

mXm.Config.API_KEY = "YOUR_API_KEY";

var successCallback = function(modelOrCollection) {
  console.log("Success:");
  console.log("  " + util.inspect(modelOrCollection));
};

var errorCallback = function(response) {
  console.log("Error callback:");
  console.log("  " + util.inspect(response));
};

mXm.API.getTrack(TRACK_ID, successCallback, errorCallback);
mXm.API.getLyrics(LYRICS_ID, successCallback, errorCallback);
mXm.API.getArtist(ARTIST_ID, successCallback, errorCallback);
mXm.API.getAlbum(ALBUM_ID, successCallback, errorCallback);
mXm.API.getSubtitle(TRACK_ID, successCallback, errorCallback);
mXm.API.searchTrack({q: QUERY}, successCallback);

If you want you can set your musiXmatch API KEY as an environment variable, and you won’t need to set it in your code:

export MUSIX_MATCH_API_KEY="YOUR_API_KEY"

You can find the source code on github.

web-app-theme 0.6.1 for rails 3

Mon, 27 Sep 2010 00:00:00 +0000

The new version of web-app-theme finally supports Rails 3. Check out the repository on github. It also supports Haml template generation using html2haml, like devise does.

UPDATE: the version 0.6.2 fixes a bug in the Haml generation when you use form_for blocks.

Ruby library for the musiXmatch API

Mon, 20 Sep 2010 00:00:00 +0000

If you want to search for lyrics and tracks with Ruby using the musiXmatch API, check out my repository at http://github.com/gravityblast/musix_match

Don't abuse NSLog in your iPhone game

Thu, 08 Apr 2010 00:00:00 +0000

I’m working on a simple game for iPhone based on cocos2d. Yesterday I installed it on my old iPhone3G and it was veeeeeeeery slow. After a lot of refactoring I found a NSLog call inside my game loop. It basically logged all the collision detection of the player with all the tiles in the map. After removing that it’s even faster then before. So, if you want to log something, do it, but remember to remove all these logging calls later.

Using CouchDB from Air applications with CouchDB Flex

Tue, 03 Nov 2009 00:00:00 +0000

In the last weeks I played a lot with CouchDB and I love it. I always used it from ruby but yesterday I tried to use it with flex. I started a new Actionscript project called CouchDB Flex, you can browse the source from github. The implementation is inspired by couchrest, but it’s asynchronous because I use URLLoader internally. Since the flash player doesn’t support the PUT and DELETE HTTP methods, you must create an AIR project if you want to try the library. You can find a compiled swc here, put it in your libs folder and you are ready to go. Here a small example, but it’s still in development, and a lot of functionality are not implemented yet.

CouchdbFlexExample.mxml: the main mxml file, it's just a window with a textarea that will display the data loaded from CouchDB.

com/gravityblast/couchdbflexexample/Contact.as: the model I'll save on CouchDB. By default the model has a name and an email, but I can add more properties since it's a dynamic class.

package com.gravityblast.couchdbflexexample
{
  import com.gravityblast.couchdb.Document;

  public dynamic class Contact extends Document
  {		
    public var name:String;
    public var email:String;
		
    public function Contact()
    {
      super();
    }
  }
}

com/gravityblast/couchdbflexexample/App.as: the main application, where I create a new Contact Document, and I load all the contacts using a view created with the Design and View classes.

package com.gravityblast.couchdbflexexample
{
  import com.gravityblast.couchdb.CouchDb;
  import com.gravityblast.couchdb.Database;
  import com.gravityblast.couchdb.Design;
  import com.gravityblast.couchdb.View;
  import com.gravityblast.couchdb.events.CouchRestEvent;
  import com.gravityblast.couchdb.events.DocumentEvent;
  import com.gravityblast.couchdb.events.ViewEvent;
	
  import mx.events.FlexEvent;
	
  import spark.components.TextArea;
  import spark.components.WindowedApplication;
	
  public class App extends WindowedApplication
  {		
    private var couchdb:CouchDb;
    private var database:Database;
		
    [Bindable]
    public 	var log:String;
    public 	var textarea:TextArea;
		
    public function App()
    {			
      this.couchdb = new CouchDb();
      this.database = this.couchdb.database("couchdb-flex-example");
      this.log = "";
      this.addEventListener(FlexEvent.CREATION_COMPLETE, this.creationCompleteHandler);
      super();
    }
		
    private function creationCompleteHandler(event:FlexEvent):void
    {			
      this.database.create(this.databaseCreateHandler);	
    }
		
    private function databaseCreateHandler(event:CouchRestEvent):void
    {
      trace(event.data);
      if (event.json.ok || event.json.error.toString() == "file_exists")
      {
        var map:String = "function(doc) {if (doc['couchdb-flex-type'] == 'com.gravityblast.couchdbflexexample::Contact') emit(null, doc);}";
        var view:View = new View("all", map);
        var design:Design = new Design("contacts");
        design.addView(view);
        design.save(this.designSaveHandler);	
      }
    }
		
    private function designSaveHandler(event:DocumentEvent):void
    {
      trace(event.data);									
      if (event.json.ok || event.json.error == "conflict")			
        this.createContacts();
      else
        trace("Error saving design document: " + event.data)			
    }
		
    private function createContacts():void
    {
      var contact:Contact = new Contact();
      contact.name    = "jack";
      contact.email   = "jack@example.com";
      contact.address = "Jack Street";
      contact.save(this.contactSaveHandler);			
    }
		
    private function contactSaveHandler(event:DocumentEvent):void
    {			
      trace(event.data);
      var contact:Contact = event.document as Contact;
      contact.address = "Jack Street updated at " + (new Date()).toString();
      contact.save(this.contactUpdateHandler);			
    }
		
    private function contactUpdateHandler(event:DocumentEvent):void
    {			
      trace(event.data);
      View.load("contacts", "all", {}, this.contactsLoadHandler);
    }
		
    private function contactsLoadHandler(event:ViewEvent):void
    {					
      for each (var contact:Contact in event.documents)
      {
        for (var property:String in contact.attributes)
        {
          this.log += property + ": " + contact[property] + "\n";	
        }
        this.log += "-------------\n";
      }
    }
  }
}

I'll write more about the library as soon as it's more stable.