Compare commits

...

12 Commits

Author SHA1 Message Date
Callum McIntyre
b362714d3c remove partial signing to test Phantom 2022-04-04 14:47:31 +01:00
Callum McIntyre
794430cb88 Test: display transaction request URL on shop/checkout page 2022-04-01 14:27:26 +01:00
Callum McIntyre
2f151312b4 Apply the coupon discount when coupon token balance is high enough 2022-03-27 17:12:08 +01:00
Callum McIntyre
f552f3d6fd Show coupon balance + send coupon on purchase 2022-03-25 15:42:03 +00:00
Callum McIntyre
6e2a127510 Add the create-coupon script 2022-03-25 15:15:31 +00:00
Callum McIntyre
6f8aba4427 Support GET request to makeTransaction API 2022-03-25 14:56:28 +00:00
Callum McIntyre
5b46d85f62 Detect payment on the /shop/checkout page 2022-03-25 14:38:05 +00:00
Callum McIntyre
22539b7fbe Add the shop page and checkout displaying a QR code 2022-03-25 11:33:30 +00:00
Callum McIntyre
2a15606b68 Update the app to charge in USDC instead of SOL 2022-03-25 10:48:55 +00:00
Callum McIntyre
f5fad1e5e3 Add /confirmed page and redirect after the transaction 2022-03-25 10:16:46 +00:00
Callum McIntyre
5e41c31eab Fetch + send transaction on checkout page 2022-03-24 17:34:07 +00:00
Callum McIntyre
6ed7e5844d Connect wallet + create transaction using API 2022-03-24 13:27:41 +00:00
18 changed files with 2962 additions and 40 deletions

25
components/Confirmed.tsx Normal file
View File

@ -0,0 +1,25 @@
import { useEffect, useState } from "react"
import { buildStyles, CircularProgressbar } from "react-circular-progressbar"
export default function Confirmed() {
const [percentage, setPercentage] = useState(0)
const [text, setText] = useState('🍪')
useEffect(() => {
const t1 = setTimeout(() => setPercentage(100), 100)
const t2 = setTimeout(() => setText('✅'), 600)
return () => {
clearTimeout(t1)
clearTimeout(t2)
}
}, [])
return (
<CircularProgressbar value={percentage} text={text} styles={
buildStyles({
pathColor: '#00BA00',
})
} />
)
}

54
components/CouponBook.tsx Normal file
View File

@ -0,0 +1,54 @@
import { getAssociatedTokenAddress, getAccount, TokenAccountNotFoundError } from "@solana/spl-token"
import { useConnection, useWallet } from "@solana/wallet-adapter-react"
import { useState, useEffect } from "react"
import { couponAddress } from "../lib/addresses"
export default function CouponBook() {
const { connection } = useConnection()
const { publicKey } = useWallet()
const [couponBalance, setCouponBalance] = useState(0)
async function getCouponBalance() {
if (!publicKey) {
setCouponBalance(0)
return
}
try {
const userCouponAddress = await getAssociatedTokenAddress(couponAddress, publicKey)
const userCouponAccount = await getAccount(connection, userCouponAddress)
const coupons = userCouponAccount.amount > 5 ? 5 : Number(userCouponAccount.amount)
console.log("balance is", coupons)
setCouponBalance(coupons)
} catch (e) {
if (e instanceof TokenAccountNotFoundError) {
// This is ok, the API will create one when they make a payment
console.log(`User ${publicKey} doesn't have a coupon account yet!`)
setCouponBalance(0)
} else {
console.error('Error getting coupon balance', e)
}
}
}
useEffect(() => {
getCouponBalance()
}, [publicKey])
const notCollected = 5 - couponBalance
return (
<>
<div className="flex flex-col bg-gray-900 text-white rounded-md p-1 items-center">
<p>Collect 5 cookies to receive a 50% discount on your next purchase!</p>
<p className="flex flex-row gap-1 place-self-center">
{[...Array(couponBalance)].map((_, i) => <span key={i}>🍪</span>)}
{[...Array(notCollected)].map((_, i) => <span key={i}>⚪</span>)}
</p>
</div>
</>
)
}

View File

@ -20,7 +20,7 @@ export default function Products({ submitTarget, enabled }: Props) {
<h3 className="text-2xl font-bold">{product.name}</h3>
<p className="text-sm text-gray-800">{product.description}</p>
<p className="my-4">
<span className="mt-4 text-xl font-bold">{product.priceSol} SOL</span>
<span className="mt-4 text-xl font-bold">${product.priceUsd}</span> {/* We updated this line */}
{product.unitName && <span className="text-sm text-gray-800"> /{product.unitName}</span>}
</p>
<div className="mt-1">
@ -29,7 +29,6 @@ export default function Products({ submitTarget, enabled }: Props) {
</div>
)
})}
</div>
<button

View File

@ -0,0 +1,19 @@
import React, { PropsWithChildren } from 'react';
export interface ConfigProviderProps {
baseUrl: string,
}
const ConfigContext = React.createContext({ baseUrl: 'https://localhost:3001' });
export function ConfigProvider(props: PropsWithChildren<ConfigProviderProps>) {
return (
<ConfigContext.Provider value={{ baseUrl: props.baseUrl }}>
{props.children}
</ConfigContext.Provider>
);
}
export function useConfig() {
return React.useContext(ConfigContext);
}

10
lib/addresses.ts Normal file
View File

@ -0,0 +1,10 @@
import { PublicKey } from "@solana/web3.js"
// Your shop wallet address
export const shopAddress = new PublicKey('EXWr1Go8UyfA39U1dfRkcH8uUvqunbRhQEUQNm36UsyQ')
// this is the same for everyone!
export const usdcAddress = new PublicKey('Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr')
// This is your token/coupon address
export const couponAddress = new PublicKey('74aFyMgbKppdab4wEVz5AXL3UGbxMkwkwgK2LVzn3MmG')

View File

@ -8,7 +8,7 @@ export default function calculatePrice(query: ParsedUrlQuery): BigNumber {
const product = products.find(p => p.id === id)
if (!product) continue;
const price = product.priceSol
const price = product.priceUsd
const productQuantity = new BigNumber(quantity as string)
amount = amount.plus(productQuantity.multipliedBy(price))
}

2244
package-lock.json generated

File diff suppressed because it is too large Load Diff

View File

@ -3,16 +3,26 @@
"scripts": {
"dev": "next dev",
"build": "next build",
"start": "next start"
"start": "next start",
"proxy": "local-ssl-proxy --source 3002 --target 3000"
},
"dependencies": {
"@solana/pay": "^0.1.3",
"@solana/spl-token": "^0.2.0",
"@solana/wallet-adapter-base": "^0.9.5",
"@solana/wallet-adapter-react": "^0.15.4",
"@solana/wallet-adapter-react-ui": "^0.9.6",
"@solana/wallet-adapter-wallets": "^0.15.5",
"@solana/web3.js": "^1.36.0",
"@tailwindcss/forms": "^0.5.0",
"bignumber.js": "^9.0.2",
"next": "latest",
"react": "^17.0.2",
"react-circular-progressbar": "^2.0.4",
"react-dom": "^17.0.2"
},
"devDependencies": {
"@types/bs58": "^4.0.1",
"@types/node": "17.0.4",
"@types/react": "17.0.38",
"autoprefixer": "^10.4.0",
@ -22,4 +32,4 @@
"tailwindcss": "^3.0.7",
"typescript": "4.5.4"
}
}
}

View File

@ -1,17 +1,65 @@
import '../styles/globals.css'
import type { AppProps } from 'next/app'
import { AppContext, AppProps, default as NextApp } from 'next/app'
import Layout from '../components/Layout'
import Head from 'next/head'
import { ConnectionProvider, WalletProvider } from '@solana/wallet-adapter-react'
import { WalletModalProvider } from '@solana/wallet-adapter-react-ui'
import { WalletAdapterNetwork } from '@solana/wallet-adapter-base'
import { clusterApiUrl } from '@solana/web3.js'
import { PhantomWalletAdapter, SolflareWalletAdapter } from '@solana/wallet-adapter-wallets'
import { ConfigProvider } from '../contexts/ConfigProvider'
// Default styles that can be overridden by your app
require('@solana/wallet-adapter-react-ui/styles.css');
interface MyAppProps extends AppProps {
host: string;
}
function MyApp({ Component, pageProps, host }: MyAppProps) {
// The network can be set to 'devnet', 'testnet', or 'mainnet-beta'.
const network = WalletAdapterNetwork.Devnet;
// You can also provide a custom RPC endpoint.
const endpoint = clusterApiUrl(network);
// @solana/wallet-adapter-wallets includes all the adapters but supports tree shaking and lazy loading --
// Only the wallets you configure here will be compiled into your application, and only the dependencies
// of wallets that your users connect to will be loaded.
const wallets = [
new PhantomWalletAdapter(),
new SolflareWalletAdapter({ network }),
];
const baseUrl = `https://${host}`;
function MyApp({ Component, pageProps }: AppProps) {
return (
<Layout>
<Head>
<title>Cookies Inc</title>
</Head>
<Component {...pageProps} />
</Layout>
<ConnectionProvider endpoint={endpoint}>
<WalletProvider wallets={wallets} autoConnect>
<WalletModalProvider>
<Layout>
<Head>
<title>Cookies Inc</title>
</Head>
<ConfigProvider baseUrl={baseUrl}>
<Component {...pageProps} />
</ConfigProvider>
</Layout>
</WalletModalProvider>
</WalletProvider>
</ConnectionProvider>
)
}
export default MyApp
MyApp.getInitialProps = async (appContext: AppContext) => {
const props = await NextApp.getInitialProps(appContext)
const { req } = appContext.ctx;
const host = req?.headers.host || 'localhost:3001';
return {
...props,
host,
};
};
export default MyApp

View File

@ -0,0 +1,211 @@
import { createTransferCheckedInstruction, getAssociatedTokenAddress, getMint, getOrCreateAssociatedTokenAccount } from "@solana/spl-token"
import { WalletAdapterNetwork } from "@solana/wallet-adapter-base"
import { clusterApiUrl, Connection, Keypair, PublicKey, Transaction } from "@solana/web3.js"
import { NextApiRequest, NextApiResponse } from "next"
import { couponAddress, shopAddress, usdcAddress } from "../../lib/addresses"
import calculatePrice from "../../lib/calculatePrice"
import base58 from 'bs58'
export type MakeTransactionInputData = {
account: string,
}
type MakeTransactionGetResponse = {
label: string,
icon: string,
}
export type MakeTransactionOutputData = {
transaction: string,
message: string,
}
type ErrorOutput = {
error: string
}
function get(res: NextApiResponse<MakeTransactionGetResponse>) {
res.status(200).json({
label: "Cookies Inc",
icon: "https://freesvg.org/img/1370962427.png",
})
}
async function post(
req: NextApiRequest,
res: NextApiResponse<MakeTransactionOutputData | ErrorOutput>
) {
try {
// We pass the selected items in the query, calculate the expected cost
const amount = calculatePrice(req.query)
if (amount.toNumber() === 0) {
console.log('Returning 400: amount = 0')
res.status(400).json({ error: "Can't checkout with charge of 0" })
return
}
// We pass the reference to use in the query
const { reference } = req.query
if (!reference) {
console.log('Returning 400: no reference')
res.status(400).json({ error: "No reference provided" })
return
}
// We pass the buyer's public key in JSON body
const { account } = req.body as MakeTransactionInputData
if (!account) {
console.log('Returning 400: no account')
res.status(400).json({ error: "No account provided" })
return
}
// We get the shop private key from .env - this is the same as in our script
const shopPrivateKey = process.env.SHOP_PRIVATE_KEY as string
if (!shopPrivateKey) {
console.log('Returning 500: shop private key not available')
res.status(500).json({ error: "Shop private key not available" })
}
const shopKeypair = Keypair.fromSecretKey(base58.decode(shopPrivateKey))
const buyerPublicKey = new PublicKey(account)
const shopPublicKey = shopKeypair.publicKey
const network = WalletAdapterNetwork.Devnet
const endpoint = clusterApiUrl(network)
const connection = new Connection(endpoint)
// Get the buyer and seller coupon token accounts
// Buyer one may not exist, so we create it (which costs SOL) as the shop account if it doesn't
const buyerCouponAccount = await getOrCreateAssociatedTokenAccount(
connection,
shopKeypair, // shop pays the fee to create it
couponAddress, // which token the account is for
buyerPublicKey, // who the token account belongs to (the buyer)
)
const shopCouponAddress = await getAssociatedTokenAddress(couponAddress, shopPublicKey)
// If the buyer has at least 5 coupons, they can use them and get a discount
const buyerGetsCouponDiscount = buyerCouponAccount.amount >= 5
// Get details about the USDC token
const usdcMint = await getMint(connection, usdcAddress)
// Get the buyer's USDC token account address
const buyerUsdcAddress = await getAssociatedTokenAddress(usdcAddress, buyerPublicKey)
// Get the shop's USDC token account address
const shopUsdcAddress = await getAssociatedTokenAddress(usdcAddress, shopPublicKey)
// Get a recent blockhash to include in the transaction
const { blockhash } = await (connection.getLatestBlockhash('finalized'))
const transaction = new Transaction({
recentBlockhash: blockhash,
// The buyer pays the transaction fee
feePayer: buyerPublicKey,
})
// If the buyer has the coupon discount, divide the amount in USDC by 2
const amountToPay = buyerGetsCouponDiscount ? amount.dividedBy(2) : amount
// Create the instruction to send USDC from the buyer to the shop
const transferInstruction = createTransferCheckedInstruction(
buyerUsdcAddress, // source
usdcAddress, // mint (token address)
shopUsdcAddress, // destination
buyerPublicKey, // owner of source address
amountToPay.toNumber() * (10 ** usdcMint.decimals), // amount to transfer (in units of the USDC token)
usdcMint.decimals, // decimals of the USDC token
)
// Add the reference to the instruction as a key
// This will mean this transaction is returned when we query for the reference
transferInstruction.keys.push({
pubkey: new PublicKey(reference),
isSigner: false,
isWritable: false,
})
// Create the instruction to send the coupon from the shop to the buyer
const couponInstruction = buyerGetsCouponDiscount ?
// The coupon instruction is to send 5 coupons from the buyer to the shop
createTransferCheckedInstruction(
buyerCouponAccount.address, // source account (coupons)
couponAddress, // token address (coupons)
shopCouponAddress, // destination account (coupons)
buyerPublicKey, // owner of source account
5, // amount to transfer
0, // decimals of the token - we know this is 0
) :
// The coupon instruction is to send 1 coupon from the shop to the buyer
createTransferCheckedInstruction(
shopCouponAddress, // source account (coupon)
couponAddress, // token address (coupon)
buyerCouponAccount.address, // destination account (coupon)
shopPublicKey, // owner of source account
1, // amount to transfer
0, // decimals of the token - we know this is 0
)
// Add the shop as a signer to the coupon instruction
// If the shop is sending a coupon, it already will be a signer
// But if the buyer is sending the coupons, the shop won't be a signer automatically
// It's useful security to have the shop sign the transaction
couponInstruction.keys.push({
pubkey: shopPublicKey,
isSigner: true,
isWritable: false,
})
// Add both instructions to the transaction
transaction.add(transferInstruction)
// Sign the transaction as the shop, which is required to transfer the coupon
// We must partial sign because the transfer instruction still requires the user
// transaction.partialSign(shopKeypair)
// Serialize the transaction and convert to base64 to return it
const serializedTransaction = transaction.serialize({
// We will need the buyer to sign this transaction after it's returned to them
requireAllSignatures: false
})
const tx2 = Transaction.from(serializedTransaction)
const serializedTx2 = transaction.serialize({
requireAllSignatures: false
})
const base64 = serializedTx2.toString('base64')
// Insert into database: reference, amount
const message = buyerGetsCouponDiscount ? "50% Discount! 🍪" : "Thanks for your order! 🍪"
// Return the serialized transaction
const responseBody = {
transaction: base64,
message,
}
console.log('returning 200', responseBody)
res.status(200).json(responseBody)
} catch (err) {
console.error(err);
res.status(500).json({ error: 'error creating transaction', })
return
}
}
export default async function handler(
req: NextApiRequest,
res: NextApiResponse<MakeTransactionGetResponse | MakeTransactionOutputData | ErrorOutput>
) {
if (req.method === "GET") {
return get(res)
} else if (req.method === "POST") {
return await post(req, res)
} else {
return res.status(405).json({ error: "Method not allowed" })
}
}

View File

@ -1,18 +1,138 @@
import { findTransactionSignature, FindTransactionSignatureError } from "@solana/pay";
import { useConnection, useWallet } from "@solana/wallet-adapter-react";
import { WalletMultiButton } from "@solana/wallet-adapter-react-ui";
import { Keypair, Transaction } from "@solana/web3.js";
import { useRouter } from "next/router";
import { useEffect, useMemo, useState } from "react";
import BackLink from "../components/BackLink";
import PageHeading from "../components/PageHeading";
import calculatePrice from "../lib/calculatePrice";
import Loading from "../components/Loading";
import { MakeTransactionInputData, MakeTransactionOutputData } from "./api/makeTransaction";
export default function Checkout() {
const router = useRouter()
const router = useRouter();
const { connection } = useConnection();
const { publicKey, sendTransaction } = useWallet();
const amount = calculatePrice(router.query)
// State to hold API response fields
const [transaction, setTransaction] = useState<Transaction | null>(null);
const [message, setMessage] = useState<string | null>(null);
// Read the URL query (which includes our chosen products)
const searchParams = new URLSearchParams();
for (const [key, value] of Object.entries(router.query)) {
if (value) {
if (Array.isArray(value)) {
for (const v of value) {
searchParams.append(key, v);
}
} else {
searchParams.append(key, value);
}
}
}
// Generate the unique reference which will be used for this transaction
const reference = useMemo(() => Keypair.generate().publicKey, []);
// Add it to the params we'll pass to the API
searchParams.append('reference', reference.toString());
// Use our API to fetch the transaction for the selected items
async function getTransaction() {
if (!publicKey) {
return;
}
const body: MakeTransactionInputData = {
account: publicKey.toString(),
}
const response = await fetch(`/api/makeTransaction?${searchParams.toString()}`, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(body),
})
const json = await response.json() as MakeTransactionOutputData
if (response.status !== 200) {
console.error(json);
return;
}
// Deserialize the transaction from the response
const transaction = Transaction.from(Buffer.from(json.transaction, 'base64'));
setTransaction(transaction);
setMessage(json.message);
console.log(transaction);
}
useEffect(() => {
getTransaction()
}, [publicKey])
// Send the fetched transaction to the connected wallet
async function trySendTransaction() {
if (!transaction) {
return;
}
try {
await sendTransaction(transaction, connection)
} catch (e) {
console.error(e)
}
}
// Send the transaction once it's fetched
useEffect(() => {
trySendTransaction()
}, [transaction])
// Check every 0.5s if the transaction is completed
useEffect(() => {
const interval = setInterval(async () => {
try {
// Check if there is any transaction for the reference
const signatureInfo = await findTransactionSignature(connection, reference, {}, 'confirmed')
router.push('/confirmed')
} catch (e) {
if (e instanceof FindTransactionSignatureError) {
// No transaction found yet, ignore this error
return;
}
console.error('Unknown error', e)
}
}, 500)
return () => {
clearInterval(interval)
}
}, [])
if (!publicKey) {
return (
<div className='flex flex-col gap-8 items-center'>
<div><BackLink href='/'>Cancel</BackLink></div>
<WalletMultiButton />
<p>You need to connect your wallet to make transactions</p>
</div>
)
}
return (
<div className="flex flex-col gap-8 items-center">
<BackLink href='/'>Cancel</BackLink>
<div className='flex flex-col gap-8 items-center'>
<div><BackLink href='/'>Cancel</BackLink></div>
<WalletMultiButton />
{message ?
<p>{message} Please approve the transaction using your wallet</p> :
<p>Creating transaction... <Loading /></p>
}
<PageHeading>Checkout {amount.toString()} SOL</PageHeading>
</div>
)
}

16
pages/confirmed.tsx Normal file
View File

@ -0,0 +1,16 @@
import 'react-circular-progressbar/dist/styles.css';
import BackLink from '../components/BackLink';
import Confirmed from '../components/Confirmed';
import PageHeading from '../components/PageHeading';
export default function ConfirmedPage() {
return (
<div className='flex flex-col gap-8 items-center'>
<BackLink href='/'>Home</BackLink>
<PageHeading>Thankyou, enjoy your cookies!</PageHeading>
<div className='h-80 w-80'><Confirmed /></div>
</div>
)
}

View File

@ -1,12 +1,28 @@
import { useWallet } from '@solana/wallet-adapter-react'
import { WalletMultiButton } from '@solana/wallet-adapter-react-ui'
import CouponBook from '../components/CouponBook'
import Products from '../components/Products'
import SiteHeading from '../components/SiteHeading'
export default function HomePage() {
// We get the public key of the connected wallet, if there is one
const { publicKey } = useWallet()
return (
<div className="flex flex-col gap-8 max-w-4xl items-stretch m-auto pt-24">
<SiteHeading>Cookies Inc</SiteHeading>
<Products submitTarget='/checkout' enabled={true} />
{/* We add the Solana wallet connect button */}
<div className="basis-1/4">
<WalletMultiButton className='!bg-gray-900 hover:scale-105' />
</div>
{/* We display the coupon book if there's a connected wallet */}
{publicKey && <CouponBook />}
{/* We disable checking out without a connected wallet */}
{/* Also the submitTarget is /checkout instead of /checkout */}
<Products submitTarget='/checkout' enabled={publicKey !== null} />
</div>
)
}

96
pages/shop/checkout.tsx Normal file
View File

@ -0,0 +1,96 @@
import { createQR, findTransactionSignature, FindTransactionSignatureError, validateTransactionSignature, ValidateTransactionSignatureError } from "@solana/pay";
import { WalletAdapterNetwork } from "@solana/wallet-adapter-base";
import { clusterApiUrl, Connection, Keypair } from "@solana/web3.js";
import { useRouter } from "next/router";
import { useEffect, useMemo, useRef } from "react";
import BackLink from "../../components/BackLink";
import PageHeading from "../../components/PageHeading";
import { useConfig } from "../../contexts/ConfigProvider";
export default function Checkout() {
const router = useRouter()
// ref to a div where we'll show the QR code
const qrRef = useRef<HTMLDivElement>(null)
// Read the URL query (which includes our chosen products)
const searchParams = new URLSearchParams();
for (const [key, value] of Object.entries(router.query)) {
if (value) {
if (Array.isArray(value)) {
for (const v of value) {
searchParams.append(key, v);
}
} else {
searchParams.append(key, value);
}
}
}
// Generate the unique reference which will be used for this transaction
const reference = useMemo(() => Keypair.generate().publicKey, []);
// Add it to the params we'll pass to the API
searchParams.append('reference', reference.toString());
console.log({ query: router.query, params: searchParams.toString() })
// Get a connection to Solana devnet
const network = WalletAdapterNetwork.Devnet
const endpoint = clusterApiUrl(network)
const connection = new Connection(endpoint)
const { baseUrl } = useConfig()
// Encode the params into the format shown
const apiUrlEncoded = encodeURIComponent(`${baseUrl}/api/makeTransaction?${searchParams.toString()}`)
const url = `solana:${apiUrlEncoded}`
console.log({ url })
// Show the QR code
useEffect(() => {
const qr = createQR(url, 512, 'transparent')
if (qrRef.current) {
qrRef.current.innerHTML = ''
qr.append(qrRef.current)
}
}, [url])
// Check every 0.5s if the transaction is completed
useEffect(() => {
const interval = setInterval(async () => {
try {
// Check if there is any transaction for the reference
await findTransactionSignature(connection, reference, {}, 'confirmed')
// Validate that the transaction has the expected recipient, amount and SPL token
// await validateTransactionSignature(connection, signatureInfo.signature, shopAddress, amount, usdcAddress, reference, 'confirmed')
router.push('/shop/confirmed')
} catch (e) {
if (e instanceof FindTransactionSignatureError) {
// No transaction found yet, ignore this error
return;
}
if (e instanceof ValidateTransactionSignatureError) {
// Transaction is invalid
console.error('Transaction is invalid', e)
return;
}
console.error('Unknown error', e)
}
}, 500)
return () => {
clearInterval(interval)
}
}, [])
return (
<div className="flex flex-col gap-8 items-center">
<BackLink href='/shop'>Cancel</BackLink>
<PageHeading>Checkout</PageHeading>
{/* div added to display the QR code */}
<div ref={qrRef} />
</div>
)
}

16
pages/shop/confirmed.tsx Normal file
View File

@ -0,0 +1,16 @@
import 'react-circular-progressbar/dist/styles.css';
import BackLink from '../../components/BackLink';
import Confirmed from '../../components/Confirmed';
import PageHeading from '../../components/PageHeading';
export default function ConfirmedPage() {
return (
<div className='flex flex-col gap-8 items-center'>
<BackLink href='/shop'>Next order</BackLink>
<PageHeading>Thankyou, enjoy your cookies!</PageHeading>
<div className='h-80 w-80'><Confirmed /></div>
</div>
)
}

11
pages/shop/index.tsx Normal file
View File

@ -0,0 +1,11 @@
import Products from '../../components/Products'
import SiteHeading from '../../components/SiteHeading'
export default function ShopPage() {
return (
<div className="flex flex-col gap-8 max-w-4xl items-stretch m-auto pt-24">
<SiteHeading>Cookies Inc</SiteHeading>
<Products submitTarget='/shop/checkout' enabled={true} />
</div>
)
}

60
scripts/create-coupon.js Normal file
View File

@ -0,0 +1,60 @@
import { createAssociatedTokenAccount, createMint, getAccount, mintToChecked } from '@solana/spl-token'
import { WalletAdapterNetwork } from '@solana/wallet-adapter-base'
import { clusterApiUrl, Connection, Keypair } from '@solana/web3.js'
import base58 from 'bs58'
// Read .env into process.env
import 'dotenv/config'
// Initialise Solana connection
const network = WalletAdapterNetwork.Devnet
const endpoint = clusterApiUrl(network)
const connection = new Connection(endpoint)
// Initialise shop account
const shopPrivateKey = process.env.SHOP_PRIVATE_KEY
if (!shopPrivateKey) {
throw new Error('SHOP_PRIVATE_KEY not set')
}
const shopAccount = Keypair.fromSecretKey(base58.decode(shopPrivateKey))
// Create the token, returns the token public key
console.log("Creating token...")
const myCouponAddress = await createMint(
connection,
shopAccount, // payer
shopAccount.publicKey, // who has permission to mint?
shopAccount.publicKey, // who has permission to freeze?
0 // decimals (0 = whole numbers)
)
console.log("Token created:", myCouponAddress.toString())
// Create the associated token account for the shop
console.log("Creating token account for the shop...")
const shopCouponAddress = await createAssociatedTokenAccount(
connection,
shopAccount, // payer
myCouponAddress, // token
shopAccount.publicKey, // who to create an account for
)
console.log("Token account created:", shopCouponAddress.toString())
// Mint 1 million coupons to the shop account
console.log("Minting 1 million coupons to the shop account...")
await mintToChecked(
connection,
shopAccount, // payer
myCouponAddress, // token
shopCouponAddress, // recipient
shopAccount, // authority to mint
1_000_000, // amount
0, //decimals
)
console.log("Minted 1 million coupons to the shop account")
const { amount } = await getAccount(connection, shopCouponAddress)
console.log({
myCouponAddress: myCouponAddress.toString(),
shopCouponAddress: shopCouponAddress.toString(),
balance: amount.toLocaleString(),
})

3
scripts/package.json Normal file
View File

@ -0,0 +1,3 @@
{
"type": "module"
}