James Platt writes:

> On Mar 15, 2021, at 7:01 PM, Beatriz Moreira wrote:
>
>> Hello! I recently used Racket as a tool to see the small step
>> execution of some smart contract languages and I was wondering if
>> there is anywhere i can submit my work or share it with the Racket
>> community.
>
> One place might be the Racket Artifacts site.  I think it's mainly
> intended for short demonstrations of code but, if yours is not too
> long, that might be the place.
>
> https://github.com/racket/racket/wiki/Artifacts
>
> I am interested in smart contracts, as well, for a possible future
> addition to a project I am working on but it will be a while before I
> get to that point.

Spritely Goblins is probably what you want to look at, or will after the
next release (v0.8) comes out:

   https://docs.racket-lang.org/goblins/index.html

In the not too distant future, Spritely and Agoric's CapTP should
converge.  Agoric's current work is all based around smart contracts:

  https://agoric.com/
  https://github.com/Agoric/agoric-sdk/issues/1827

There's a lot of confusion out there about what "smart contracts" mean;
most of the examples tend to assume it has to do with blockchains.  In
fact, work on smart contracts precedes blockchains by several decades.
If you look at http://www.erights.org/ on which many of the ideas in
Spritely Goblins is based, you'll notice that it has the word "smart
contracts" prominently, yet this was well over a decade before
blockchains even existed.  What the heck?

Smart contracts as something implemented with distributed objects can be
best understood probably by reading Capability Based Financial Instruments:

  http://erights.org/elib/capability/ode/index.html

The mint example from that paper is implemented in Goblins:

  
https://gitlab.com/spritely/goblins/-/blob/dev/goblins/actor-lib/simple-mint.rkt

That's right, in about 25 lines of Goblins code you can have a
functioning bank of sorts, which preserves financial integrity and even
permits networked accounts.  No blockchain required.

Yet, you could add a blockchain, or even turn Goblins into a blockchain
if you wanted.  (Since Goblins' actor state is transactional and
snapshottable, you can have a merkle tree of all inputs, and global
consensus on the set of messages accepted by the network, and all
participants can replay and simulate the same abstract machine.  This is
fairly trivial to do in Goblins.)

But more interestingly, Agoric has already done the work of abstracting
even remote blockchains as abstract machines on the network.  Since
we'll be implementing the same CapTP, when the time comes you'll be able
to access all that for free, even though Agoric programs are written in
Javascript and Goblins programs in Racket.

Anyway, the next release of Goblins, coming soon, should allow for
beginning to play with this kind of stuff on the network more easily
than in the present (v0.7) stuff, which currently takes a lot of work.
So maybe if you can wait a few weeks, it'll be easier to talk about.

But "smart contracts" is a use case, a broad problem domain.  What kind
of smart contracts are you wanting to write?

 - Chris

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/87h7lac36a.fsf%40dustycloud.org.

Reply via email to