I think it's all there. Thought this would be harder to add but I was able to copy-paste my way to victory.

I just added the functionality as directly as I could, copying Solana's existing API. Not sure if that's what was wanted or not, but we can have a discussion now that the PR is here.

Closes #41

Currently, passing pubkeys and/or byte arrays as seeds is not supported by Seahorse compiler as it throws an error like seen in the screenshot, the same happens with an array of u8s or any other integer type

Variables are not correctly assigned if they are defined in a certain level and their value is changed in a different one. For example, consider the following instruction:

@instruction
def test(signer: Signer, number: f64):
   myboolean=True
   newnumber=1.0
   if number > 0.0:
      myboolean=False
      newnumber=10.0
      print(f'Your boolean is {myboolean}. Extra number: {newnumber}.')
   print(f'Your number is {number}.')
   print(f'Your boolean is {myboolean}. Extra number: {newnumber}.')

When the previous instruction is executed with the number 5.0 as an input, the output is

Program log: Instruction: Test
Program log: Your boolean is false. Extra number: 10.
Program log: Your number is 5.
Program log: Your boolean is true. Extra number: 1.

which is clearly an undesired behaviour.

Since strings in Rust don't implement Copy, we need to call .clone() when we read these fields of an event. This PR adds logic to add .clone() for only strings.

I've also added an event example which shows various different field types in events. I found that lists and arrays also don't work, but will also need further work, so I've opened a separate issue for them: #64

Closes #61

This means that if we compile the same code repeatedly the output is identical. The motivation for this is to allow adding lightweight infrastructure to detect whether/how a PR changes the compile output for the example Python files. Having a stable output is a prerequisite for this to avoid false positives where eg. functions are just rearranged.

Where we've used HashMap and HashSet data structures the sort order is undefined, and in practice if you compile multiple times you'll get different outputs.

See suggestion in Discord: https://discordapp.com/channels/1005658120548270224/1006027721127776388/1042345155522474034

To test this I compiled the examples 20 times each:

# examples/
for f in ./*.py
do
    for i in {1..20}
    do
        ../target/debug/seahorse compile $f > compiled/$f$i.rs
    done
done

And then verified with md5 compiled/* that all instances of the same file are identical

Intentionally didn't update changelog BTW! :D

Adds methods (instance and static) for struct-type classes (a.k.a., non-enums). Accounts may not define constructors, since Solana needs to know they exist instead of just existing transiently in memory.

Example usage:

class Point:
    x: i32
    y: i32

    # Constructor defined like in Python
    # Caveat: structs now derive `Default`, and have all of their fields set to
    # their default values
    def __init__(self, x: i32, y: i32):
        self.x = x
        self.y = y

    # Giving a method a `self` parameter makes it an instance method
    def manhattan_dist(self) -> i32:
        return self.x + self.y

    # No self = static method - no @staticmethod needed
    def origin() -> Point:
        return Point(0, 0)

# ...

@instruction
def ix(...):
    p = Point(2, 3)
    q = Point.origin()

    print(p.manhattan_dist(), q.manhattan_dist())

This PR is intended to improve our robustness, by requiring that any changes to the compiled output of the example Seahorse files is know about and reviewed. This should mostly avoid me introducing more bugs :p

I've tested it on my own fork:

• Success: https://github.com/mcintyre94/seahorse-lang/actions/runs/3550019740
• Error (caused by a change in the compiler): https://github.com/mcintyre94/seahorse-lang/actions/runs/3550014723

It hasn't run on this PR, I assume that's a github security limitation for new workflows.

Note that currently the examples are quite limited, there are many areas they don't cover. Improving this in future PRs would be a valuable contribution, and double as extra documentation! But in particular because they're all single files being compiled with seahorse compile, the Python imports feature can't currently be tested with it. We might want to add some examples using seahorse build in a full-fledged seahorse project going forward. But I think this is a good start and that most things will be better served by simple single file tests.

• Changes the behaviour of len(str) to match Python and return a character count. Eg len("ƒoo") is 3. This is a change from the current behaviour which uses Rust's str.len() and would return 4.

• Adds a new function size(str) which gets the size in bytes of a string. This uses Rust's str.len().

This is intended to be a step toward supporting strings on accounts by allowing custom account sizing. Code like assert len(content) < 280, "tweet is too long!" will now behave the same as in Python, allowing up to 280 unicode characters. Asserting on size is also possible if required.

And the extra space would be defined as 4 + size(content) when we have that capability.

I split this into a separate PR because it's a breaking change of len.

• Make rustfmt-wrapper a conditional dependency, exclude for wasm
• Conditionally exclude code that uses rustfmt when compiling for wasm

Pretty much the same as what I did before, except the beautify function makes it a bit cleaner!

Should make no change for non-wasm targets, while allowing cargo build --target wasm32-unknown-unknown to work again!

Closes #20

This PR adds support for strings! The end result is that we can now compile code such as:

class Tweet(Account):
  owner: Pubkey
  tweet: String[280]

@instruction
def new_tweet(author: Signer, tweet_account: Empty[Tweet], tweet: String[280]):
  tweet_account.init(payer=author, seeds = ['tweet', author])
  tweet_account.owner = author.key()

  assert len(tweet) <= 280, "Tweet must be no more than 280 characters"
  tweet_account.tweet = tweet

This involves the following changes:

• A new String[N] type is added to the compiler. In the seahorse AST this is stored as Ty::StringOfLength(len), so Seahorse always knows the maximum length of a string. In the generated Rust it is simply a String
• When we initialize a new account, we add the length of any StringOfLength(n) fields on it to the size. This is necessary because Rust doesn't know the length of strings and std::mem::size_of::<String> is a small constant
• The new String[N]type is added to the prelude
• Python's len function is updated to support strings. This works slightly differently to the existing implementation for arrays, which returns the defined length. For strings we generate Rust code that computes the actual length, eg. tweet.chars().count(). This means that you can assert on the length of a string as in the example above

I've also updated the way we put string constants in Rust to add the .to_string() so you can also write tweet_account.tweet = "hello world" and it'll compile to tweet_account.tweet = "hello world!".to_string();

Also note that this will slightly over-estimate the space required for the string. I've added a comment, but because we're already doing std::mem::size_of::<Account> this includes a small number of bytes (24 in Rust playground) for the String. I'm not subtracting this from the number I calculate because I'm not sure how constant it is.

Anchor supports a (reference to an) array of U8 values as a seed value. Using this allows the client-side code to be more straightforward than having each value as its own seed, since we can pack the array into a single buffer: Buffer.from([x, y]).

This PR adds support for this to Seahorse, such that this becomes valid:

@instruction
def create_pixel(
  pixel: Empty[Pixel],
  user: Signer,
  pos_x: u8,
  pos_y: u8
):
  # Initialise pixel account
  pixel_account = pixel.init(
    payer = user,
    seeds = ["pixel", [pos_x, pos_y]]
  )

The generated accounts context has seeds:

#[derive(Accounts)]
# [instruction (pos_x : u8 , pos_y : u8)]
pub struct CreatePixel<'info> {
    #[account(
        init,
        payer = user,
        seeds = ["pixel".as_bytes().as_ref(), [pos_x, pos_y].as_ref()],
        bump,
        space = 8 + std::mem::size_of::<Pixel>()
    )]
    pub pixel: Box<Account<'info, Pixel>>,
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
}

The PDA can then be generated in JS:

const [pixelPublicKey] = web3.PublicKey.findProgramAddressSync(
  [Buffer.from("pixel"), Buffer.from([x, y])],
  program.programId,
)

From experimenting with Anchor I think only an array of U8 needs to be supported. A string/pubkey/longer number would take multiple bytes and then you'd have a nested list which Anchor doesn't seem to like. So I think it's only Array of U8 that should be supported.

Closes #4

• Seahorse actually uses whichever version of Anchor you have installed/active, so no need to explicitly bump it
• But there was a dependency clash between pyth-sdk-solana 0.6.1 and Anchor 0.26.0 (on solana-program-library) causing a compile error on seahorse build
• Bumping to 0.7.0 works with both Anchor 0.25.0 and Anchor 0.26.0
• Also tested with all examples on Anchor 0.26.0

Closes #80

When compiling the code

# Built with Seahorse v0.2.5

from seahorse.prelude import *

declare_id('2U2z3rSoeJYEAkLoStCn676EunGSXXt9HVQCcp7d9PB7')

def mystring() -> str:
  return 'abc'

I obtain the following error message:

✗ Compiling test... Error: anchor build -p test failed:

This is most likely a bug in the Seahorse compiler!

If you want to help the project, you can report this:

• on the Seahorse Discord (http://discord.gg/4sFzH5pus8)
• or as a Github issue (https://github.com/ameliatastic/seahorse-lang/issues).

Thanks!

Compiling test v0.1.0 (/home/miguel/Aldrin/Programming/Seahorse/test/programs/test) error[E0308]: mismatched types --> programs/test/src/dot/program.rs:10:12 | 9 | pub fn mystring() -> String { | ------ expected String because of return type 10 | return "abc"; | ^^^^^- help: try using a conversion method: .to_string() | | | expected struct String, found &str

For more information about this error, try rustc --explain E0308. error: could not compile test due to previous error

If I replace return 'abc' with return str('abc'), the code compiles without errors.

Released yesterday, changelog: https://github.com/coral-xyz/anchor/blob/master/CHANGELOG.md

• Includes the upstream fix for the issue this PR was trying to address in seahorse: https://github.com/ameliatastic/seahorse-lang/pull/56
• Has some breaking changes we'll need to check seahorse against

Context

I wanted to have a tokenMint signed for by a program, so it uses a protocol as the mint and freeze authority

Issue

When trying to pass in the protocol and its bump as signer, I got an error message

# random
# Built with Seahorse v0.2.5

from seahorse.prelude import *

declare_id("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS")


class Protocol(Account):
    bump: u8


@instruction
def init_protocol(signer: Signer, protocol: Empty[Protocol]):
    protocol = protocol.init(payer=signer, seeds=["protocol"])
    bump = Pubkey.find_program_address(["protocol"])[1]

    protocol.bump = bump


@instruction
def init_mint(signer: Signer, mint: Empty[TokenMint], protocol: Protocol):
    mint = mint.init(payer=signer, authority=protocol, decimals=u8(6))


@instruction
def use_bump(
    signer: Signer,
    protocol: Protocol,
    mint: TokenMint,
    destination_token_account: TokenAccount,
):

    bump = protocol.bump
    mint.mint(
        authority=protocol,
        to=destination_token_account,
        amount=u64(100000),
        signer=["protocol", protocol.bump],
    )

output

Error: anchor build -p bugreport failed:

This is most likely a bug in the Seahorse compiler!

If you want to help the project, you can report this:
  - on the Seahorse Discord (http://discord.gg/4sFzH5pus8)
  - or as a Github issue (https://github.com/ameliatastic/seahorse-lang/issues).

Thanks!

   Compiling bugreport v0.1.0 (/Users/purpleparakeet/work/bugreport/programs/bugreport)
error[E0609]: no field `bump` on type `seahorse_util::Mutable<LoadedProtocol<'info, '_>>`
  --> programs/bugreport/src/dot/program.rs:84:26
   |
84 |                 protocol.bump.to_le_bytes().as_ref(),
   |                          ^^^^ unknown field

For more information about this error, try `rustc --explain E0609`.
error: could not compile `bugreport` due to previous error

but when I assign protocol.bump to a variable and pass it in the same way, I get no such message

# random
# Built with Seahorse v0.2.5

from seahorse.prelude import *

declare_id("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS")


class Protocol(Account):
    bump: u8


@instruction
def init_protocol(signer: Signer, protocol: Empty[Protocol]):
    protocol = protocol.init(payer=signer, seeds=["protocol"])
    bump = Pubkey.find_program_address(["protocol"])[1]

    protocol.bump = bump


@instruction
def init_mint(signer: Signer, mint: Empty[TokenMint], protocol: Protocol):
    mint = mint.init(payer=signer, authority=protocol, decimals=u8(6))


@instruction
def use_bump(
    signer: Signer,
    protocol: Protocol,
    mint: TokenMint,
    destination_token_account: TokenAccount,
):

    bump = protocol.bump
    mint.mint(
        authority=protocol,
        to=destination_token_account,
        amount=u64(100000),
        signer=["protocol", bump],
    )

I think this behavior is surprising, so I'm filing it as a bug.

I was trying to use a bump as a signer. When trying to recreate the issue with the minimum reproducible code, I noticed that this program that I would expect to compile, wouldn't

Source code:

# bugreport
# Built with Seahorse v0.2.5

from seahorse.prelude import *

declare_id("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS")


class Protocol:
    bump: u8


@instruction
def init_protocol(signer: Signer, protocol: Empty[Protocol]) -> Program:
    protocol = protocol.init(payer=signer, seeds=["protocol"])
    protocol.bump = u8(0)

Error message on seahorse build

seahorse build ⠋ Compiling bugreport...thread 'main' panicked at 'explicit panic', src/core/compile/build/mod.rs:248:18 note: run with RUST_BACKTRACE=1 environment variable to display a backtrace ⠙ Compiling bugreport...%

Putting some thoughts into a branch for how to tackle this problem. Context.

Basically, the compiler needs a way for context to be passed down to expressions. When the build stage is run and a Rust-like AST is generated, the entire tree is built from the leaves up. This means that expressions like a = f(x, y) will first build the syntax tree component for a, x, then y, then combine those to make f(x, y), then combine those to make a = f(x, y).

This introduces a small problem: the innermost expressions have no way of knowing the context that they're being created in. An example that's been resolved in a somewhat hacky way: a very simple assignment statement like

x.a = y.b

needs to be turned into something like

x.borrow_mut().a = y.borrow().b;

due to how mutability is handled. Even though syntactically, the (Python) expressions on the left and right are exactly the same, they need to generated different (Rust) expressions! Right now this is handled by just traversing the LHS a second time and making all of the borrows mutable borrows, but this could easily lead to unforeseen problems. It would be much cleaner to just generate the right code the first time.

However, getting there is a challenge, because this involves actually changing the compiler, and maybe changing it significantly. On this PR I'll be looking trying to figure out a good way of solving the problem. Any outside help would be greatly appreciated. Thanks!