Forem: ddm4313

Creating a marketplace with Stripe Connect: The onboarding process

ddm4313 — Tue, 26 Nov 2024 20:54:16 +0000

Introduction

Creating a marketplace probably would be too hard, or impossible considering that not many payment processors offer it, if they do not offer it then you would be likely booted off the platform the moment they got wind of it, and even without that it is risky to create a marketplace where you don't have a solid foundation to handle payments, refunds and payouts to the sellers using the platform.

Stripe Connect addresses these issues, it will allow us to create a basic marketplace where you can sign up to be a seller, and customers can purchase items from these sellers with ease. As a platform owner you can also set your service fee, so when user X purchases from store Y then we'll get X% cut of that transaction but more on that later.

Setting up the project

For handling the database connection we are using Prisma, authentication is being handled by remix-auth, for this part we are solely handling the seller's side of the marketplace.


// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model Store {
  id         String   @id // This will be the store's subdomain
  name       String
  updated_at DateTime @default(now()) @updatedAt
  seller     Seller?
}

model Seller {
  id           Int      @id @default(autoincrement())
  email        String
  password     String
  store        Store    @relation(fields: [store_id], references: [id])
  date_created DateTime @default(now())
  date_updated DateTime @updatedAt
  store_id     String   @unique
}

This is what our schema.prisma file looks like, we have a Seller model and a Store model related to it, the "id" field will serve as the subdomain so when we get to the buyer's side I will be able to visit at store.localhost.com and purchase the products from the seller there.
And we'll also add a Stripe model, which will store data about the seller's Connect account.

model Stripe {
  account_id String @id
  is_onboarded Boolean @default(false)
  user Users @relation(fields: [user_id], references: [discord_id])
  user_id String @unique
  created_at DateTime @default(now())
  updated_at DateTime @updatedAt
}

model Seller {
  id           Int      @id @default(autoincrement())
  email        String
  password     String
  store        Store    @relation(fields: [store_id], references: [id])
  date_created DateTime @default(now())
  date_updated DateTime @updatedAt
  store_id     String   @unique
  stripe       Stripe?
}

Now we can deal with onboarding the user, so let's define another variable in our .env file.

STRIPE_SK=your stripe secret key here

You may get the Stripe secret key by generating it in Stripe's dev page, it is a good idea to create a restricted key that will for now only allow the use of Stripe Connect.

Then you will need to create a new file which will export the Stripe client so it can be used by our routes

// app/libs/stripe.server.ts
import Stripe from 'stripe';
export const stripe = new Stripe(process.env.STRIPE_SK)

We'll create a new route that will be at "/onboarding"

// app/routes/onboarding.tsx

export default function Onboarding() {
    const {stripe} = useLoaderData();

    return <div className={'text-center pt-[6%]'}>
    <h1 className={'text-xl'}>Account onboarded: {stripe?.is_onboarded ? stripe?.account_id : '🔴 Not connected'}</h1>
        <div className={'flex items-center  text-white text-sm  mt-5 justify-center gap-3'}>
            {!stripe ? <>
                <Form method={'post'}>
                    <button type={'submit'} className={'bg-blue-600 hover:cursor-pointer  rounded-[6px] px-4 py-1.5'}>Setup your seller
                        account
                    </button>

                </Form>
            </> : <>
                <div className={'bg-blue-600 rounded-[6px] px-4 py-1.5'}>Seller dashboard</div>

            </>}
        </div>
    </div>
}

We'll add a loader function which will pass the data concerning seller's onboarding status

export async function loader({request}: LoaderFunctionArgs) {
    const user = await authenticator.isAuthenticated(request, {
        failureRedirect: '/login'
    })

    const seller = await prisma.seller.findFirst({
        where: {
            id: user.id
        }, include: {
            stripe: true
        }
    })

    return {
        stripe: seller?.stripe
    }
}

Now if you go to /onboarding it would say that you are not connected, and you'll be able to press a button to sign up, this is where our action function comes in

export async function action({request}: ActionFunctionArgs) {
    const authenticated = await authenticator.isAuthenticated(request, {
        failureRedirect: '/login'
    })
    const seller = await prisma.seller.findFirst({
        where: {
            id: authenticated.id
        }, include: {
            stripe: true
        }
    })
    if (seller && seller.stripe?.is_onboarded) {
        return json({
            message: 'User is onboarded already',
            error: true
        }, {
            status: 400
        })
    }
    const account = seller?.stripe?.account_id ? {
        id: seller.stripe?.account_id
    } : await stripe.accounts.create({
        email: seller?.email,
        controller: {
            fees: {
                payer: 'application',
            },
            losses: {
                payments: 'application',
            },
            stripe_dashboard: {
                type: 'express',
            },
        },
    });
    if (!seller?.stripe?.account_id) {
        await prisma.seller.update({
            where: {
                id: authenticated.id
            },
            data: {
                stripe: {
                    create: {
                        account_id: account.id
                    }
                }
            }, include: {
                stripe: true
            }
        })
    }
    const accountLink = await stripe.accountLinks.create({
        account: account.id,
        refresh_url: 'http://localhost:5173/onboarding',
        return_url: 'http://localhost:5173/onboarding',
        type: 'account_onboarding',
        collection_options: {
            fields: 'eventually_due',
        },
    });
    console.debug(`[ACCOUNT ID = ${account.id}] CREATED ACCOUNT ONBOARDING LINK, REDIRECTING...`)

    return redirect(accountLink.url)
}

When the seller presses the button we'll create an account with the email they signed up with, then we'll create an Account Link which will redirect them to an onboarding page, if the seller already has a Stripe account attached but is not onboarded, then we also redirect them to the onboarding link.

From there the seller will enter his email/phone number, and the onboarding process will begin, Stripe will usually ask the seller for location of the business, business details, bank accounts etc...

Now we can listen to webhooks for Stripe Connect events, so when a seller has onboarded successfully we'll add those attributes to the Seller's record in the database.

For testing, you can simply download Stripe CLI and from there you can forward any events to our new route /api/notifications which we will create now

stripe listen --forward-to localhost:5173/api/notifications

When you run that command you will be given a webhook signature, so that we may verify the integrity of each webhook sent to us by Stripe, equally if you create a webhook on the developer portal on Stripe you'll have a secret.

Ready! You are using Stripe API Version [2020-03-02]. Your webhook signing secret is whsec_SECRET

We'll also add a new variable in the .env file

WEBHOOK_SECRET=whsec_SECRET

Now we can write the code to handle these events being sent to us by Stripe

import {ActionFunctionArgs} from "@remix-run/node";
import {stripe} from "~/libs/stripe.server";
import Stripe from "stripe";

export const action = async ({request}: ActionFunctionArgs) => {
    const sig = request.headers.get('stripe-signature')
    let event: Stripe.Event;
    const payload = await request.text()

    try {
        event = stripe.webhooks.constructEvent(payload, sig as string, process.env.WEBHOOK_SECRET as string)
    } catch(err) {
        return new Response('Something went wrong...', {
            status: 500,
        })
    }

}

We verify that it's Stripe sending the request, if it is then we move on, now the event we want to look out for is account.updated, that event is related to the Account we created before redirecting the seller.

When a seller starts the onboarding process, adds his phone number, or enters the email, or finally completes the onboarding process we'll get the 'account.updated' event and that will have this array sent with it

account.requirements.currently_due

When 'currently_due' array's length is at zero then we know the user is fully onboarded, able to accept payments and so from our side we can update the database and allow the user to create products, but before we do that let's add this logic in the '/api/notifications' action

if (event.type === 'account.updated') {
    console.log(`[WEBHOOK] Handling account.updated event`);
    try {
        const account = event.data.object;
        const currently_due = account.requirements?.currently_due;
        if (currently_due?.length === 0) {
            console.log(`[WEBHOOK] Account ${account.id} is fully onboarded`);
            await prisma.stripe.update({
                where: {
                    account_id: account.id,
                },
                data: {
                    is_onboarded: true
                },
            });

        }
    } catch (e) {
        console.error('[WEBHOOK] Error while handling account.updated event:', e);
    }

}
return new Response(null, {
    status: 200
})

Once that is in place we can try onboarding and see if it works. As soon as you enter the address for example, you will see a message in the console of the project such as

[WEBHOOK] Handling account.updated event

So that means that the body is validated and we are successfully receiving events from Stripe, but let's see if onboarding will work.

Once you get to the final step it'll probably say that your account details are incomplete, the last step is ID verification, since this is test mode we can simulate that

Okay so once we have done that we'll return to the previous page and we can press submit, press submit and we'll get in the console

[WEBHOOK] Account acct_1QPUWnPunrQwLVEX is fully onboarded

That works, now Stripe will return us to the onboarding page and it'll show us our account ID which means we have successfully onboarded and we can start creating products.

Alright, let's just make that seller dashboard button functional before we move on to products, create a new route which will be at /portal

// app/routes/portal.ts

import {LoaderFunctionArgs, redirect} from "@remix-run/node";
import {authenticator} from "~/services/authentication.server";
import {prisma} from "~/services/db.server";
import {stripe} from "~/libs/stripe.server";

export async function loader({request}: LoaderFunctionArgs) {
    const authenticated = await authenticator.isAuthenticated(request, {
        failureRedirect: '/login'
    })

    const seller = await prisma.seller.findFirstOrThrow({
        where: {
            id: authenticated.id
        }, include: {
            stripe: true
        }
    })
    if (!seller.stripe) throw new Response(null, {
        status: 400
    })
    const loginLink = await stripe.accounts.createLoginLink(seller.stripe.account_id);
    return redirect(loginLink.url)
}

Very basic function, so now when you go to /portal if you are onboarded you'll be redirected to the one-use link we generate for the Stripe Account.

In the onboarding route we'll make wrap the Seller dashboard div with a Link.

<Link to={`/portal`}> <div className={'bg-blue-600 rounded-[6px] px-4 py-1.5'}>Seller dashboard</div> </Link>

When we visit /portal or press the button we'll be redirected to Stripe's Portal for Connect accounts, there the user can see his analytics, payouts etc...

This marks the end of part one of our creating a marketplace with Stripe Connect, part two will deal with products, payments and payouts, part three will be the final and there we'll deal with the customer facing side of the project.

You can see the source code of the project at https://github.com/ddm50/stripe-connect-howto-seller

Creating a Solana Coinflip game with Orao Network's VRF

ddm4313 — Sun, 26 May 2024 15:19:56 +0000

Creating a Solana Coinflip game with Orao Network's VRF

Writing a game such as Coinflip in Solana may seem a bit of a taunting task given that you can not simply generate a random number based off the clock, or a blockhash. These are typically used for examples but those can be manipulated by a bad actor and as such are not secure. To build a secure game, any kind of game that relies on a random result in Solana must use an oracle.

The main oracle providers in Solana today are Switchboard and Orao Network, I have used both but today I find Orao to be a bit more easy to use.

We'll start by initiating the Anchor project in our terminal:

anchor init solana-coinflip-game

We'll first work on the contract itself and the PDA, then we'll slowly add VRF to it so it's fully secure and that it generates a verifiably random result.

We need to add a few Cargo crates first, solana-program, anchor_spl and orao-network-vrf

[dependencies]
anchor-lang = "0.29.0"
orao-solana-vrf = {version="=0.3.0",default-features = false, features = ["cpi"]}
anchor-spl = "=0.29.0"
solana-program = "=1.18.14"

At the time of writing this postI am using anchor 0.29.0 and this is how your [dependencies] should look in your Cargo.toml under programs/solana-coinflip-game, of course at the time of writing this is how it looks but depending on when you're reading it may be different.

We'll create a new file named pda.rs, this file will store the pda details such as user_1 and user_2, winner and status of the game.


use anchor_lang::prelude::*;
use solana_program::{
    system_program::ID as SYSTEM_PROGRAM_ID,
    };
use anchor_spl::token::{self,
        ID as TOKEN_PROGRAM_ID};


#[derive(Debug, AnchorSerialize, AnchorDeserialize, Clone, Copy, PartialEq, Eq)]
pub enum Status {
    Waiting,
    Processing,
    Finished
}


#[account]
#[derive(Default)]
pub struct Coinflip {

    user_1: Pubkey,
    user_2: Pubkey,
    amount: u64,
    winner: Pubkey,
    status: Status
}


#[derive(Accounts,)]
#[instruction( room_id: String,amount: u64)]
pub struct CreateCoinflip<'info> {
    #[account(mut)]
    pub user: Signer<'info>,

    #[account(
            init,
            space = 8 + std::mem::size_of::<Coinflip>(),

            payer = user,
            seeds = [b"coinflip", room_id.as_bytes().as_ref()],
            bump
    )]
    pub coinflip: Account<'info, Coinflip>,


    pub system_program: Program<'info, System>,
}

We have an enum Status for the game, Waiting meaning game is waiting for the 2nd player to join the room, Processing meaning that game has already started and that randomness is currently being generated.

CreateCoinflip will initiate the game and the PDA account, it'll place the bet and set user_1 and amount variable in the PDA, than in the next method we write we'll utilize these variables and require that amount when another user joins the room.

Let us now write the create_coinflip function in lib.rs


pub fn create_coinflip(ctx: Context<CreateCoinflip>, room_id: String, amount: u64) -> Result<()> {

        if (amount < 50000000) {
            return err!(InvalidAmount::InvalidAmount);
        }

        let coinflip = &mut ctx.accounts.coinflip;

        invoke(
            &transfer(
                ctx.accounts.user.to_account_info().key,
                coinflip.clone().to_account_info().key,
                amount,
            ),
            &[
                ctx.accounts.user.to_account_info(),
                coinflip.clone().to_account_info(),

                ctx.accounts.system_program.to_account_info(),
            ],
        );
        coinflip.user_1 = ctx.accounts.user.clone().to_account_info().key();
        coinflip.amount = amount;

        msg!("Coinflip game is initiated");

        Ok(())
}

Here we introduce an error InvalidAmount if a user tries to place a bet less than 0.05 SOL or 50000000 lamports then the error is thrown.

#[error_code]
pub enum InvalidAmount {
    #[msg("Amount must be greater than 0.05 SOL")]
    InvalidAmount
}

The create_coinflip function will also transfer the amount inputted from the user to the coinflip account, this is essentially an escrow account that holds the funds while the bet is being processed, when it is we'll have the funds sent to the winner.

Next function is joinroom_coinflip, this'll mirror the create_coinflip function, it simply places the 2nd bet which means now we can write the final functions which will send for a randomness and process the result.


#[derive(Accounts,)]
#[instruction(room_id: String)]
pub struct JoinRoomCoinflip<'info> {
    #[account(mut)]
    pub user: Signer<'info>,

    #[account(
            mut,
            seeds = [b"coinflip", room_id.as_bytes().as_ref()],
            bump
    )]
    pub coinflip: Account<'info, Coinflip>,



    #[account(address = SYSTEM_PROGRAM_ID)]
    pub system_program: Program<'info, System>,
    #[account(address = TOKEN_PROGRAM_ID)]
    pub token_program: Program<'info, Token>,
}

You'll notice the PDA for this function is only different in that the Coinflip account no longer has init and space in its definition, now we can just edit it as it's already initialized and exists.

// src/lib.rs

pub fn join_coinflip(ctx: Context<JoinRoomCoinflip>, room_id: String) -> Result<()> {
        let coinflip = &mut ctx.accounts.coinflip;

        invoke(
            &transfer(
                ctx.accounts.user.to_account_info().key,
                coinflip.clone().to_account_info().key,
                coinflip.amount.clone(),
            ),
            &[
                ctx.accounts.user.to_account_info(),
                coinflip.clone().to_account_info(),

                ctx.accounts.system_program.to_account_info(),
            ],
        );
        coinflip.user_2 = ctx.accounts.user.clone().to_account_info().key();
        coinflip.amount =   coinflip.amount.clone();

        msg!("Coinflip game can start, user 2 has entered the game");

        Ok(())
}

We'll start integrating Orao Network's verifiable randomness now, the next function will start the game and request a randomness from the oracle.

The next method is PlayCoinflip, we'll add this in pda.rs

// pda.rs
#[derive(Accounts)]
#[instruction(room_id: String, force: [u8; 32])]
pub struct PlayCoinflip<'info> {
    #[account(mut)]
    pub user: Signer<'info>,


    #[account(
        mut, 
        seeds = [b"coinflip", room_id.as_bytes().as_ref()],
        constraint =
        coinflip.user_1 == user.to_account_info().key(),
        bump
    )] 
    pub coinflip: Account<'info, Coinflip>,



    /// CHECK: Treasury
    #[account(mut)]
    pub treasury: AccountInfo<'info>,


    /// CHECK: Randomness
    #[account(
        mut,
        seeds = [RANDOMNESS_ACCOUNT_SEED.as_ref(), &force],
        bump,
        seeds::program = orao_solana_vrf::ID
    )]
    pub random: AccountInfo<'info>,

    #[account(
        mut,
        seeds = [CONFIG_ACCOUNT_SEED.as_ref()],
        bump,
        seeds::program = orao_solana_vrf::ID
    )]
    pub config: Account<'info, NetworkState>,

    pub vrf: Program<'info, OraoVrf>,

    pub system_program: Program<'info, System>,
}

We'll also start writing the tests now after we implement the function in lib.rs under play_coinflip

// lib.rs

 pub fn play_coinflip(ctx: Context<PlayCoinflip>,room_id: String, force: [u8; 32]) -> Result<()> {
        let player = &ctx.accounts.user;
        let room = &mut ctx.accounts.coinflip;



        msg!("Coinflip in room {} game started", room_id);

        let cpi_program = ctx.accounts.vrf.to_account_info();
        let cpi_accounts = orao_solana_vrf::cpi::accounts::Request {
            payer: ctx.accounts.user.to_account_info(),
            network_state: ctx.accounts.config.to_account_info(),
            treasury: ctx.accounts.treasury.to_account_info(),
            request: ctx.accounts.random.to_account_info(),
            system_program: ctx.accounts.system_program.to_account_info(),
        };
        let cpi_ctx = anchor_lang::context::CpiContext::new(cpi_program, cpi_accounts);
        orao_solana_vrf::cpi::request(cpi_ctx, force)?;

        room.force = force;
        room.status = Status::Processing;
        msg!("Started game in room {}", room_id);
        return Ok(());

}

You'll find the example on their site is not like this, it's much more complicated. Though it's actually far more simple if you take it apart and make it your own as I have here.

With this function the game now starts, and the randomness is being processed by the oracle. Now we'll write some tests and then we'll conclude it with a final function which will use the randomness result and transfer the funds to the winner.

When we initiated the project with Anchor, the command already generated some example tests for us so we'll start with the first function which initiates the game. We'll set the network variable to be Devnet in Anchor.toml

[provider]
cluster = "Devnet"

Now we'll anchor build and anchor deploy and when we deploy we'll get something like this ![alt]

The program ID is different than what the example generates, so we'll need to replace that, in my case I'll replace

declare_id("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

with the new program ID that we got by deploying it on devnet

declare_id("64CRrSCxSoEUDv2Sg3fKrwxotoiyD1bfce1AyCeuF582");

We can add this statement to Anchor.toml as well

[programs.devnet]
solana_coinflip_game = "64CRrSCxSoEUDv2Sg3fKrwxotoiyD1bfce1AyCeuF582"

We'll need to build and deploy again otherwise it'll fail as it uses the old program id and we'd get Error: AnchorError occurred. Error Code: DeclaredProgramIdMismatch. Error Number: 4100. Error Message: The declared program id does not match the actual program id., you can make it use the original program id Anchor generates when it first deploys, but I didn't do that here, so just redeploy and we can start testing.

You should also install @solana/web3.js for this part, using npm, let's write the test now:

import * as anchor from "@project-serum/anchor";
import { Program } from "@project-serum/anchor";
import { SolanaCoinflipGame } from "../target/types/solana_coinflip_game";
import { LAMPORTS_PER_SOL, PublicKey, SystemProgram } from "@solana/web3.js";
import { BN } from "bn.js";
import { TOKEN_PROGRAM_ID } from "@project-serum/anchor/dist/cjs/utils/token";

function randomString(length=8) {
  let result = '';
  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  const charactersLength = characters.length;
  let counter = 0;
  while (counter < length) {
    result += characters.charAt(Math.floor(Math.random() * charactersLength));
    counter += 1;
  }
  return result;
}
describe("solana-coinflip-game", () => {
  // Configure the client to use the local cluster.
  anchor.setProvider(anchor.AnchorProvider.env());

  const program = anchor.workspace.SolanaCoinflipGame as Program<SolanaCoinflipGame>;
  const payer = anchor.Wallet.local().payer
  const keypair = Keypair.generate()

  const room_id = randomString()
  const amount = LAMPORTS_PER_SOL * 0.1
  const [coinflip] = PublicKey.findProgramAddressSync(
    [Buffer.from("coinflip"), Buffer.from(room_id)],
    program.programId
  );

  it("Is initialized!", async () => {
    // Add your test here.



    const tx = await program.methods.createCoinflip(room_id,new BN(amount)).accounts({
      coinflip,
      user: payer.publicKey,
      systemProgram: SystemProgram.programId,

    }).signers([
      payer
    ]).rpc({
      skipPreflight: true
    });
    console.log("Your transaction signature", tx);
    console.log("Program account data: ", await program.account.coinflip.fetch(coinflip))
  });
});

We'll find the PDA account with two strings, coinflip which is the constant and room_id being random, these two are seeds which are used to find the Coinflip account.

The amount we bet is 0.1 SOL, and then we call the createCoinflip function, after that the transaction is sent and you can see the account data, immediately amount and user_1 are defined, you'll also find that the Coinflip account now has 0.1 SOL which we just transferred by calling this function.

Now let's add our second player so we can execute joinCoinflip function, which will simply be a randomly generated keypair, we'll transfer some SOL to that address so we can place a bet.

it("Transfer SOL to player2", async () => {

    const transferTransaction = new Transaction().add(
      SystemProgram.transfer({
        fromPubkey: payer.publicKey,
        toPubkey: keypair.publicKey,
        lamports: LAMPORTS_PER_SOL*0.11,
      })
    )

    var tx =await sendAndConfirmTransaction(anchor.getProvider().connection, transferTransaction, [payer]);
    console.log("TX executed", tx)
})

This'll transfer 0.11 SOL to the 2nd player, the 2nd player being the keypair variable we defined just below the program variable, a random keypair. This is the result after running anchor test for the 2nd time, you can run tests without deploying with anchor test --skip-deploy --skip-build.

Next test we'll add is to join the room, the test for initiating game is not much different to this, they are both essentially the same, except the user in this case becomes keypair.publicKey, that's our 2nd player.

it("Join game", async () => {
      const tx = await program.methods.joinCoinflip(room_id).accounts({
      coinflip,
      user: keypair.publicKey,
      systemProgram: SystemProgram.programId,

    }).signers([
      keypair
    ]).rpc({
      skipPreflight: true
    });

    console.log("Your transaction signature", tx);
    console.log("Program account data: ", await program.account.coinflip.fetch(coinflip))
  });

And this is the result, keypair.publicKey becomes user2 and now we can proceed to writing the last two functions and getting verifiable randomness.

Now let us proceed to testing play_coinflip function we created previously, for this you must install @orao-network/solana-vrf with npm. Let's start with initiating the next test.

it("Play the game", async () => {
    const random = randomnessAccountAddress(force.toBuffer());
    const treasury = new PublicKey("9ZTHWWZDpB36UFe1vszf2KEpt83vwi27jDqtHQ7NSXyR");
})

const vrf = new Orao(anchor.getProvider() as any);
let force = Keypair.generate().publicKey;

We'll add these two variables on top so we may use them in other tests not just the one where we request a randomness. You can also simply define treasury at the top.

Force is a kind of a seed we pass to Orao, it's just a random public key converted to a buffer. In this devnet testing example the Orao treasury is 9ZTHWWZDpB36UFe1vszf2KEpt83vwi27jDqtHQ7NSXyR.

Let's call the function now so we can wrap this up

const tx = await program.methods.playCoinflip( room_id, [...force.toBuffer()]).accounts({
      user: payer.publicKey,
      coinflip: coinflip,
      vrf: vrf.programId,
      config: networkStateAccountAddress(),
      treasury: treasury,
      random,
    }).signers([payer]).rpc();

    const tx = await program.methods.playCoinflip( room_id, [...force.toBuffer()]).accounts({
      user: payer.publicKey,
      coinflip: coinflip,
      vrf: vrf.programId,
      config: networkStateAccountAddress(),
      treasury: treasury,
      random,
    }).signers([payer]).rpc();

console.log(`Game has started, randomness is requested: `, tx)

As you may see everything went as planned here, we called the function successfully and the tx went through. That means that randomness has been requested, typically it takes less than 10seconds for it to resolve. We have also set the status to processing, this'll play into our last function

How do we know when it's ready? Simple, Orao has a function waitFulfilled, we pass the force variable to it which we used when we requested the randomness and then it'll resolve when it's fulfilled.

it("Randomness fulfilled", async () => {
    let randomnessFulfilled = await vrf.waitFulfilled(force.toBuffer())
    console.log("Randomness is fulfilled, we can call the result function")
  })

Okay, now we can move forward with our last function which will get the winner out of the two, both players have a 50/50 chance of winning. First let's create a new file, misc.rs:

// misc.rs
use anchor_lang::{
    solana_program::{account_info::AccountInfo, program_error::ProgramError},
    AccountDeserialize,
};
use orao_solana_vrf::state::Randomness;

pub fn get_account_data(account_info: &AccountInfo) -> Result<Randomness, ProgramError> {
    if account_info.data_is_empty() {
        return Err(ProgramError::UninitializedAccount);
    }

    let account = Randomness::try_deserialize(&mut &account_info.data.borrow()[..])?;

    if false {
        Err(ProgramError::UninitializedAccount)
    } else {
        Ok(account)
    }
}

And for the last part, we'll deal with the result and deciding who's the winner, let's create a new struct inside pda.rs

// pda.rs

#[derive(Accounts)]
#[instruction(room_id: String, force: [u8; 32])]
pub struct ResultCoinflip<'info> {
    #[account(
        mut, 
        seeds = [b"coinflip", room_id.as_bytes().as_ref()],
        constraint =
        coinflip.status == Status::Processing,
        bump
    )] 
    pub coinflip: Account<'info, Coinflip>,



    /// CHECK: Treasury
    #[account(mut)]
    pub treasury: AccountInfo<'info>,


    /// CHECK: Randomness
    #[account(
        mut,
        seeds = [RANDOMNESS_ACCOUNT_SEED.as_ref(), &force],
        bump,
        seeds::program = orao_solana_vrf::ID
    )]
    pub random: AccountInfo<'info>,

    #[account(
        mut,
        seeds = [CONFIG_ACCOUNT_SEED.as_ref()],
        bump,
        seeds::program = orao_solana_vrf::ID
    )]
    pub config: Account<'info, NetworkState>,

    pub vrf: Program<'info, OraoVrf>,

    pub system_program: Program<'info, System>,
}

What is different about this compared to the play_coinflip function? Not much, really here we're just getting the result and deciding the winner, we also have a constraint that checks if the game has started, if not then the contract will throw an error.

// misc.rs

pub fn result_coinflip(ctx: Context<ResultCoinflip>,room_id: String, force: [u8; 32]) -> Result<()> {

        let rand_acc = crate::misc::get_account_data(&ctx.accounts.random)?;

        let randomness = current_state(&rand_acc);
        if (randomness == 0) {
            return err!(StillProcessing::StillProcessing)
        }
        let result = randomness % 2;

    }

We are also introducing a new function current_state, this'll get the VRF result, convert it to a number, and then % 2, that will end up in a result that is either 0 or 1. You can add this function inside misc.rs, as well as a new error for when randomness is still not fulfilled.

// misc.rs
pub fn current_state(randomness: &Randomness) ->u64 {
    if let Some(randomness) = randomness.fulfilled() {
        let value = randomness[0..size_of::<u64>()].try_into().unwrap();

        return u64::from_le_bytes(value);
    } else {
        return 0;

    }
}

// lib.rs
#[error_code]
pub enum StillProcessing {
    #[msg("Randomness is still being fulfilled")]
    StillProcessing
}

Since we want to transfer the funds to the winner, we have to add both of the accounts to the struct, and also a constraint to make sure that this can't be abused by a third party that wants to fool the contract.

We'll add user_1 and user_2 to the struct and then create a few constraints to prevent bad actors

// pda.rs

#[account(mut)]
pub user_1: AccountInfo<'info>,

#[account(mut)]
pub user_2: AccountInfo<'info>,

#[account(
        mut, 
        seeds = [b"coinflip", room_id.as_bytes().as_ref()],
        constraint =
        (coinflip.status == Status::Processing,
        coinflip.user_1 == user_1.key(),
        coinflip.user_2 == user_2.key()),

        bump
)]

When we have done this let's finish our result_coinflip function

// lib.rs @ result_coinflip 

msg!("VRF result is: {}", randomness);
if (result ==0) {
      coinflip.winner = coinflip.user_1.key();
            **ctx.accounts.user_1.lamports.borrow_mut() = ctx.accounts.user_1.lamports()
            .checked_add(coinflip.amount.clone())
            .unwrap();
             **coinflip.to_account_info().lamports.borrow_mut() -= coinflip.amount.clone();

             msg!("Winner is user_1: {}", coinflip.user_1.key().to_string())

} else {
      coinflip.winner = coinflip.user_2.key();
            **ctx.accounts.user_2.lamports.borrow_mut() = ctx.accounts.user_2.lamports()
            .checked_add(coinflip.amount.clone())
            .unwrap();
             **coinflip.to_account_info().lamports.borrow_mut() -= coinflip.amount.clone();
       msg!("Winner is user_2: {}", coinflip.user_2.key().to_string())


}

We already have the result with the result variable being randomness % 2, what these statements do is transfer the funds to the winner as well as marking them as the winner, and for the last trick we'll mark the game as finished, so the function should now look like this

// lib.rs

pub fn result_coinflip(ctx: Context<ResultCoinflip>,room_id: String, force: [u8; 32]) -> Result<()> {
        let coinflip = &mut ctx.accounts.coinflip;
        let rand_acc = crate::misc::get_account_data(&ctx.accounts.random)?;

        let randomness = current_state(&rand_acc);
        if (randomness == 0) {
            return err!(StillProcessing::StillProcessing)
        }
        let result = randomness % 2;

        msg!("VRF result is: {}", randomness);
        if (result ==0) {
            coinflip.winner = coinflip.user_1.key();
            **ctx.accounts.user_1.lamports.borrow_mut() = ctx.accounts.user_1.lamports()
            .checked_add(coinflip.amount.clone() * 2)
            .unwrap();
             **coinflip.to_account_info().lamports.borrow_mut() -= coinflip.amount.clone() * 2;

             msg!("Winner is user_1: {}", coinflip.user_1.key().to_string())

        } else {
            coinflip.winner = coinflip.user_2.key();
            **ctx.accounts.user_2.lamports.borrow_mut() = ctx.accounts.user_2.lamports()
            .checked_add(coinflip.amount.clone() *2)
            .unwrap();
             **coinflip.to_account_info().lamports.borrow_mut() -= coinflip.amount.clone() * 2;
             msg!("Winner is user_2: {}", coinflip.user_2.key().to_string())


        }
        msg!("Coinflip game in room {} has concluded, the winner is {}", room_id, coinflip.winner.to_string());
        coinflip.status = Status::Finished;



        return Ok(())
}

Let's write the final test and we can see just how well everything runs

it("Get the result", async () => {   const vrf = new Orao(anchor.getProvider() as any);

    const random = randomnessAccountAddress(force.toBuffer());
    const treasury = new PublicKey("9ZTHWWZDpB36UFe1vszf2KEpt83vwi27jDqtHQ7NSXyR");

    const tx = await program.methods.resultCoinflip( room_id, [...force.toBuffer()]).accounts({
      user1: payer.publicKey,
      user2: keypair.publicKey,
      coinflip: coinflip,
      vrf: vrf.programId,
      config: networkStateAccountAddress(),
      treasury: treasury,
      random,
    }).signers([payer]).rpc();


    console.log(`Game is finished`, tx)
    console.log("Program account data: ", await program.account.coinflip.fetch(coinflip))

  })

And what do we get?

This is how the account data should look after we get the result, the winner is decided, in this case the random user won over me, and status is set to finished. And this marks it, no insecure blockhashes or clocks, merely using the Orao Network's oracle to have a proper Coinflip game that can't be fooled by anyone.

The result is 12037561925398644525, hence 12037561925398644525 % 2 = 0, the winner is the second user .

You can also see how the funds get transferred from the escrow coinflip account to the address of player user_2, the winner gets all, so he gets 0.2 SOL.

And that's it, a bit of a longer reader but as simple as it seems dealing with smart contracts and oracles takes some time and this post reflects.

But as usual, I have my code on Github and you can feel free to take a stab at it, just make sure to read what I have to say about the deployment of the contract in the beginning otherwise you might run into some difficulties. https://github.com/ddm50/solana-coinflip-game

Modals with Remix

ddm4313 — Fri, 24 May 2024 00:54:33 +0000

Modals with Remix

Using Remix I have found it second nature to use modal routes when I can. Instead of using useState and passing data to the modal component, a modal route can be created under the parent route, and it being a route there is no need to pass data that may not be used if a user chooses not to open the modal. Less mess, more simplicity.

Since it is a route, you can use loader as well action, I have found that for most cases useState is unnecessary, and more messy when using Remix.

In this post I'll create a modal route that creates a user entry in the database to portray how simple and effortless using Remix can be. Much less time thinking about how to do something, more time spent on doing what is important.

First we'll initialize Prisma by creating a file called db.server.ts

// app/db.server.ts

import { PrismaClient } from "@prisma/client"                  

declare global {
  var __prisma: PrismaClient
}

if (!global.__prisma) {
  global.__prisma = new PrismaClient()
}
global.__prisma.$connect()

export const prisma = global.__prisma

// prisma/schema.prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "sqlite"
  url      = env("DATABASE_URL")
}

model Post {
  id    Int     @id @default(autoincrement())
  title String
  name  String
  date_created DateTime @default(now())
  date_updated DateTime @default(now())
}

We'll also create a route file called posts.tsx, we'll render the posts from the database here, we use a loader to pass the data from the database to the user:

import type {LoaderFunctionArgs, MetaFunction} from "@remix-run/node";
import {prisma} from "~/db.server";
import {Link, Outlet, useLoaderData} from "@remix-run/react";

export const meta: MetaFunction = () => {
  return [
    { title: "New Remix App" },
    { name: "description", content: "Welcome to Remix!" },
  ];
};

export default function Index() {
  const {posts} = useLoaderData();

  return (
    <div className={'w-[80%] m-auto p-6'}>
     <nav className={'mb-6'}>
       <h1 className={'text-2xl font-medium'}>Posts</h1>
         <Link to={'/posts/create'}>
             <button className={'bg-blue-600 px-5 py-1.5 text-white text-sm text-center rounded-[8px]'}>Create</button>

         </Link>
     </nav>
      <div >
        <table className={'text-left'}>
          <thead >
          <tr>
            <th scope="col" >
              Post ID
            </th>
            <th scope="col">
              Title
            </th>
            <th scope="col" >
              Name
            </th>
            <th scope="col" >
              Last updated
            </th>
            <th scope="col" >
Actions
            </th>
          </tr>
          </thead>
          <tbody>
          {posts.map(post => <tr >
            <th scope="row" >
              {post.id}
            </th>
            <td>
              {post.title}
            </td>
            <td >
              {post.name}
            </td>
            <td >
              {post.date_updated}
            </td>
            <td className={'text-left'} >
          <Link className={'text-left'} to={`/posts/${post.id}`}>
            Edit
          </Link>
            </td>
          </tr>)}
          </tbody>
        </table>
      </div>
      <Outlet/>
    </div>
  );
}

export async function loader({request}: LoaderFunctionArgs) {
  const posts = await prisma.post.findMany()

  return {posts}
}
}

export async function loader({request}: LoaderFunctionArgs) {
  const posts = await prisma.post.findMany()

  return {posts}
}

This will render all the posts from the database, first we will deal with the first modal route that creates a post in the database.

First we must create a file posts.create.tsx, but naming a file like that is not enough for the modal to appear on top of posts, an <Outlet/> must exist inside the posts.tsx route.

// posts.create.tsx
import {useEffect} from "react";
import {Form, Link, redirect} from "@remix-run/react";
import {ActionFunctionArgs} from "@remix-run/node";
import {z} from "zod";
import {zx} from "zodix";
import {prisma} from "~/db.server";

export default function Create() {
    return <div id="default-modal" tabIndex="-1" aria-hidden="true"
                className="bg-black bg-opacity-60 overflow-y-auto overflow-x-hidden fixed top-0 right-0 left-0 z-50 justify-center items-center w-full md:inset-0 h-[calc(100%-1rem)] h-full">
        <div className="relative p-4 w-full m-auto  mt-[7%] max-w-2xl max-h-full">
            <div className="relative bg-white rounded-lg shadow">
                <Form method={'post'}>
                <div className="flex items-center justify-between p-4 md:p-5 border-b rounded-t">
                    <h3 className="text-xl font-semibold text-gray-900 ">
                        Create post
                    </h3>
                    <Link to={'/posts'}>
                        <button type="button"
                                className="text-gray-400 bg-transparent hover:bg-gray-200 hover:text-gray-900 rounded-lg text-sm w-11 h-11 ms-auto inline-flex justify-center items-center"
                                data-modal-hide="default-modal">
                            <svg className="w-4 h-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none"
                                 viewBox="0 0 14 14">
                                <path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                                      d="m1 1 6 6m0 0 6 6M7 7l6-6M7 7l-6 6"/>
                            </svg>
                            <span className="sr-only">Close modal</span>
                        </button>
                    </Link>
                </div>
                <div className="p-4 md:p-5 space-y-4">
                    <div>
                        <label htmlFor="title"
                               className="block mb-2 text-sm font-medium text-gray-900">Title</label>
                        <input type="text" name={'title'}
                               className="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-blue-500 focus:border-blue-500 block w-full p-2.5 "
                               placeholder="Enter a title here" required/>
                    </div>
                </div>
               <div className={'flex justify-between items-center'}>
                   <div>

                   </div>
                   <div className="flex items-center p-4 md:p-5 border-t border-gray-200 rounded-b">
                       <button data-modal-hide="default-modal" type="submit"
                               className="text-white bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:outline-none focus:ring-blue-300 font-medium rounded-lg text-sm px-5 py-2.5 text-center">Submit
                       </button>
                       <Link to={'/posts'}>
                           <button data-modal-hide="default-modal" type="button"
                                   className="py-2.5 px-5 ms-3 text-sm font-medium text-gray-900 focus:outline-none bg-white rounded-lg border border-gray-200 hover:bg-gray-100 hover:text-blue-700 focus:z-10 focus:ring-4 focus:ring-gray-100">Cancel
                           </button>
                       </Link>
                   </div>
               </div>
                </Form>
            </div>
        </div>
    </div>
}

You will notice as it is often with Remix that there is no JS here, closing the modal simply takes you back to /posts which is the parent route.

Now we will add an action which will create a new post when the user submits the form. We will validate the request body with Zodix, a module that allows us to use Zod to parse FormData.

function slugify(str: string) {
    str = str.replace(/^\s+|\s+$/g, ''); // trim leading/trailing white space
    str = str.toLowerCase(); // convert string to lowercase
    str = str.replace(/[^a-z0-9 -]/g, '') // remove any non-alphanumeric characters
        .replace(/\s+/g, '-') // replace spaces with hyphens
        .replace(/-+/g, '-'); // remove consecutive hyphens
    return str;
}

export async function action({request}: ActionFunctionArgs) {
    const { title } = await zx.parseForm(request, {
        title: z.string(),
    });

    const slug = slugify(title);

    await prisma.post.create({
        data: {
            title,
            name: slug
        }
    })


    return redirect("/posts?created=true")
}

We will redirect the user to /posts with a URL param that will let the user know that the post has been created successfully, that is often times achieved with session.flash but as this is a simple example this suffices.

// app/root.tsx

const [searchParams, setSearchParams] = useSearchParams()

useEffect(() => {
        if (searchParams.get('created')) {
            alert("Post created")
            const params = new URLSearchParams();
            params.delete("created");
            setSearchParams(params, {
                preventScrollReset: true,
            });
        }
}, [searchParams])

And the result is simplicity of a modal route, no need to have a state to manage the modal, or an API route to handle the creation of a post. The code is more clean and organized, and with a modal route like posts.create.tsx the action is found in that file as well, and it handles the task of creating a post entirely.

A modal route has many different possibilities, user settings, editing posts, creating posts. And that is the appeal of a modal route, simplicity in code and less clutter.

You can find the source code here: https://github.com/ddm50/modals-with-remix