diff --git a/Anchor.toml b/Anchor.toml index f6f99e7..0920466 100644 --- a/Anchor.toml +++ b/Anchor.toml @@ -2,6 +2,10 @@ seeds = true skip-lint = false +[programs.localnet] +referrals = "AyiEeNNyt46iRMeN1kNUfBjdu9GdsDxuH7zAg9CgyLRC" +plege = "7xMy6CDMk3ANhRBEMorr9A3EJt5qWcQq64MeqGdC9JpA" + [programs.devnet] referrals = "AyiEeNNyt46iRMeN1kNUfBjdu9GdsDxuH7zAg9CgyLRC" plege = "7xMy6CDMk3ANhRBEMorr9A3EJt5qWcQq64MeqGdC9JpA" @@ -10,7 +14,7 @@ plege = "7xMy6CDMk3ANhRBEMorr9A3EJt5qWcQq64MeqGdC9JpA" url = "https://api.apr.dev" [provider] -cluster = "devnet" +cluster = "localnet" wallet = "~/.config/solana/id.json" [scripts] diff --git a/tests/basic.ts b/tests/basic.ts index 9cb442b..c8d2f4e 100644 --- a/tests/basic.ts +++ b/tests/basic.ts @@ -1,21 +1,21 @@ -import * as anchor from "@project-serum/anchor" +import * as anchor from "@project-serum/anchor"; import { createAssociatedTokenAccount, getAccount, mintToChecked, -} from "@solana/spl-token" -import { BN, Program } from "@project-serum/anchor" -import chai from "chai" -import chaiAsPromised from "chai-as-promised" +} from "@solana/spl-token"; +import { BN, Program } from "@project-serum/anchor"; +import chai from "chai"; +import chaiAsPromised from "chai-as-promised"; import { cancelSubscription, completePayment, createSubscription, -} from "./utils/basic-functions" -import { Plege } from "../target/types/plege" +} from "./utils/basic-functions"; +import { Plege } from "../target/types/plege"; -chai.use(chaiAsPromised) -const expect = chai.expect +chai.use(chaiAsPromised); +const expect = chai.expect; describe("basic flow", () => { it("creates user", async () => { @@ -25,8 +25,8 @@ describe("basic flow", () => { auth: global.testKeypairs.colossal.publicKey, }) .signers([global.testKeypairs.colossal]) - .rpc() - }) + .rpc(); + }); it("creates app", async () => { await program.methods @@ -37,13 +37,13 @@ describe("basic flow", () => { treasury: global.testKeypairs.hacker.publicKey, }) .signers([global.testKeypairs.colossal]) - .rpc() + .rpc(); - const appPDA = await program.account.app.fetch(app) + const appPDA = await program.account.app.fetch(app); expect(appPDA.auth.toBase58()).to.equal( global.testKeypairs.colossal.publicKey.toBase58() - ) - }) + ); + }); it("create tier", async () => { await program.methods @@ -53,13 +53,13 @@ describe("basic flow", () => { signer: global.testKeypairs.colossal.publicKey, }) .signers([global.testKeypairs.colossal]) - .rpc() + .rpc(); - const tierPDA = await program.account.tier.fetch(tier) - expect(tierPDA.app.toBase58()).to.equal(app.toBase58()) - expect(tierPDA.price.toNumber()).to.equal(10) - expect((tierPDA.interval as any).month).to.not.equal(undefined) - }) + const tierPDA = await program.account.tier.fetch(tier); + expect(tierPDA.app.toBase58()).to.equal(app.toBase58()); + expect(tierPDA.price.toNumber()).to.equal(10); + expect((tierPDA.interval as any).month).to.not.equal(undefined); + }); it("create subscription", async () => { const { subscription, subscriptionThread } = await createSubscription( @@ -67,42 +67,42 @@ describe("basic flow", () => { tier, global.testKeypairs.subscriber, subscriberAta - ) + ); const subscriptionPDA = await program.account.subscription.fetch( subscription - ) + ); - expect(subscriptionPDA.app.toBase58()).to.equal(app.toBase58()) - expect(subscriptionPDA.tier.toBase58()).to.equal(tier.toBase58()) + expect(subscriptionPDA.app.toBase58()).to.equal(app.toBase58()); + expect(subscriptionPDA.tier.toBase58()).to.equal(tier.toBase58()); expect(subscriptionPDA.subscriber.toBase58()).to.equal( global.testKeypairs.subscriber.publicKey.toBase58() - ) - const startTime = new Date(subscriptionPDA.start.toNumber() * 1000) - expect(new Date().getTime() - startTime.getTime()).to.be.lessThan(5000) + ); + const startTime = new Date(subscriptionPDA.start.toNumber() * 1000); + expect(new Date().getTime() - startTime.getTime()).to.be.lessThan(5000); expect(subscriptionPDA.start.toNumber()).to.equal( subscriptionPDA.payPeriodExpiration.toNumber() - ) - }) + ); + }); it("completes payment", async () => { - const before = await program.account.subscription.fetch(subscription) + const before = await program.account.subscription.fetch(subscription); - await completePayment(app, tier, hackerAta, subscriberAta, subscription) + await completePayment(app, tier, hackerAta, subscriberAta, subscription); const subscriptionPDA = await program.account.subscription.fetch( subscription - ) + ); - const ownerATA = await getAccount(global.connection, hackerAta) + const ownerATA = await getAccount(global.connection, hackerAta); - let payPeriod = new Date(before.payPeriodExpiration.toNumber() * 1000) - payPeriod.setMonth(payPeriod.getMonth() + 1) + let payPeriod = new Date(before.payPeriodExpiration.toNumber() * 1000); + payPeriod.setMonth(payPeriod.getMonth() + 1); expect(subscriptionPDA.payPeriodExpiration.toNumber() * 1000).to.equal( payPeriod.getTime() - ) - expect(Number(ownerATA.amount)).to.equal(10) - }) + ); + expect(Number(ownerATA.amount)).to.equal(10); + }); it("cancels subscription", async () => { await cancelSubscription( @@ -110,13 +110,13 @@ describe("basic flow", () => { tier, global.testKeypairs.subscriber, subscriberAta - ) + ); const subscriptionPDA = await program.account.subscription.fetch( subscription - ) - expect(subscriptionPDA.acceptNewPayments).to.equal(false) - }) + ); + expect(subscriptionPDA.acceptNewPayments).to.equal(false); + }); it("attempting to create subscription again fails", async () => { expect( @@ -126,10 +126,10 @@ describe("basic flow", () => { global.testKeypairs.subscriber, subscriberAta ) - ).to.eventually.be.rejected - }) + ).to.eventually.be.rejected; + }); - // it("can close subscription") + // it("can close subscription"); // it("can create subscription again after closing account", async () => { // await global.program.methods @@ -143,83 +143,85 @@ describe("basic flow", () => { // subscriberAta, // }) // .signers([global.testKeypairs.subscriber]) - // .rpc() + // .rpc(); // const subscriptionPDA = await global.program.account.subscription.fetch( // subscription - // ) + // ); - // expect(subscriptionPDA.app.toBase58()).to.equal(app.toBase58()) - // expect(subscriptionPDA.tier.toBase58()).to.equal(tier.toBase58()) + // expect(subscriptionPDA.app.toBase58()).to.equal(app.toBase58()); + // expect(subscriptionPDA.tier.toBase58()).to.equal(tier.toBase58()); // expect(subscriptionPDA.subscriber.toBase58()).to.equal( // global.testKeypairs.subscriber.publicKey.toBase58() - // ) - // const startTime = new Date(subscriptionPDA.start * 1000) - // expect(new Date().getTime() - startTime.getTime()).to.be.lessThan(5000) + // ); + // const startTime = new Date(subscriptionPDA.start * 1000); + // expect(new Date().getTime() - startTime.getTime()).to.be.lessThan(5000); // expect(subscriptionPDA.start.toNumber()).to.equal( // subscriptionPDA.payPeriodExpiration.toNumber() - // ) - // }) + // ); + // }); before(async () => { - program = global.program as Program - ;[app] = anchor.web3.PublicKey.findProgramAddressSync( + program = global.program as Program; + [app] = anchor.web3.PublicKey.findProgramAddressSync( [ Buffer.from("APP"), global.testKeypairs.colossal.publicKey.toBuffer(), new BN([1]).toArrayLike(Buffer, "be", 1), ], program.programId - ) - ;[tier] = anchor.web3.PublicKey.findProgramAddressSync( + ); + [tier] = anchor.web3.PublicKey.findProgramAddressSync( [ Buffer.from("SUBSCRIPTION_TIER"), app.toBuffer(), new BN([1]).toArrayLike(Buffer, "be", 1), ], program.programId - ) - ;[subscription] = anchor.web3.PublicKey.findProgramAddressSync( + ); + [subscription] = anchor.web3.PublicKey.findProgramAddressSync( [ Buffer.from("SUBSCRIPTION"), app.toBuffer(), global.testKeypairs.subscriber.publicKey.toBuffer(), ], program.programId - ) + ); threadProgram = new anchor.web3.PublicKey( "3XXuUFfweXBwFgFfYaejLvZE4cGZiHgKiGfMtdxNzYmv" - ) - ;[thread] = anchor.web3.PublicKey.findProgramAddressSync( + ); + [thread] = anchor.web3.PublicKey.findProgramAddressSync( [ Buffer.from("thread"), subscription.toBuffer(), Buffer.from("subscriber_thread"), ], threadProgram - ) + ); colossalAta = await createAssociatedTokenAccount( global.connection, global.testKeypairs.colossal, global.mint, global.testKeypairs.colossal.publicKey - ) + ).catch((err) => { + console.log(err); + }); subscriberAta = await createAssociatedTokenAccount( global.connection, global.testKeypairs.subscriber, global.mint, global.testKeypairs.subscriber.publicKey - ) + ); hackerAta = await createAssociatedTokenAccount( global.connection, global.testKeypairs.hacker, global.mint, global.testKeypairs.hacker.publicKey - ) + ); await mintToChecked( global.connection, @@ -229,8 +231,8 @@ describe("basic flow", () => { global.testKeypairs.colossal.publicKey, 1000 * 10 ** 5, 5 - ) - }) + ); + }); let colossalAta, subscriberAta, @@ -239,7 +241,7 @@ describe("basic flow", () => { tier, subscription, thread, - threadProgram + threadProgram; - let program: Program -}) + let program: Program; +}); diff --git a/tests/referrals.ts b/tests/referrals.ts index f8dbeb6..1521f5a 100644 --- a/tests/referrals.ts +++ b/tests/referrals.ts @@ -1,28 +1,32 @@ -import { assert } from "chai" +import { assert } from "chai"; import { AccountMeta, Keypair, PublicKey, SystemProgram, Transaction, -} from "@solana/web3.js" -import * as anchor from "@project-serum/anchor" -import { Referrals } from "../target/types/referrals" -import { Plege } from "../target/types/plege" -import generateFundedKeypair from "./utils/keypair" +} from "@solana/web3.js"; +import * as anchor from "@project-serum/anchor"; +import { Referrals } from "../target/types/referrals"; +import { Plege } from "../target/types/plege"; +import generateFundedKeypair from "./utils/keypair"; import { findAppAddress, findSubscriptionAddress, tierAccountKey, userAccountKeyFromPubkey, -} from "./utils/basic-functions" +} from "./utils/basic-functions"; import { createAssociatedTokenAccount, createMint, mintTo, TOKEN_PROGRAM_ID, -} from "@solana/spl-token" -import { keypairIdentity, Metaplex, mockStorage } from "@metaplex-foundation/js" +} from "@solana/spl-token"; +import { + keypairIdentity, + Metaplex, + mockStorage, +} from "@metaplex-foundation/js"; function findReferralshipAddress( app: PublicKey, @@ -31,7 +35,7 @@ function findReferralshipAddress( return PublicKey.findProgramAddressSync( [Buffer.from("REFERRALSHIP"), app.toBuffer()], programId - ) + ); } function findReferralAddress( @@ -48,7 +52,7 @@ function findReferralAddress( referralAgentNFTMint.toBuffer(), ], programId - ) + ); } function findReferralshipTreasuryAccountAddress( @@ -64,23 +68,23 @@ function findReferralshipTreasuryAccountAddress( treasuryMint.toBuffer(), ], programId - ) + ); } describe("referrals", () => { - anchor.setProvider(anchor.AnchorProvider.env()) + anchor.setProvider(anchor.AnchorProvider.env()); const referralProgram = anchor.workspace - .Referrals as anchor.Program - const subscriptionProgram = anchor.workspace.Plege as anchor.Program + .Referrals as anchor.Program; + const subscriptionProgram = anchor.workspace.Plege as anchor.Program; it("creates a referralship", async () => { - const { connection } = anchor.getProvider() - const appAuthorityKeypair = await generateFundedKeypair(connection) - const referralAgentKeypair = await generateFundedKeypair(connection) - const subscriberKeypair = await generateFundedKeypair(connection) - const stakeholder1Keypair = await generateFundedKeypair(connection) - const stakeholder2Keypair = await generateFundedKeypair(connection) - const treasuryAuthorityKeypair = await generateFundedKeypair(connection) + const { connection } = anchor.getProvider(); + const appAuthorityKeypair = await generateFundedKeypair(connection); + const referralAgentKeypair = await generateFundedKeypair(connection); + const subscriberKeypair = await generateFundedKeypair(connection); + const stakeholder1Keypair = await generateFundedKeypair(connection); + const stakeholder2Keypair = await generateFundedKeypair(connection); + const treasuryAuthorityKeypair = await generateFundedKeypair(connection); // create a token mint const treasuryMint = await createMint( @@ -89,43 +93,43 @@ describe("referrals", () => { treasuryAuthorityKeypair.publicKey, treasuryAuthorityKeypair.publicKey, 0 - ) + ); const referralAgentTokenAccount = await createAssociatedTokenAccount( connection, referralAgentKeypair, treasuryMint, referralAgentKeypair.publicKey - ) + ); const subscriberTokenAccount = await createAssociatedTokenAccount( connection, subscriberKeypair, treasuryMint, subscriberKeypair.publicKey - ) + ); const stakeholder1TokenAccount = await createAssociatedTokenAccount( connection, stakeholder1Keypair, treasuryMint, stakeholder1Keypair.publicKey - ) + ); const stakeholder2TokenAccount = await createAssociatedTokenAccount( connection, stakeholder1Keypair, treasuryMint, stakeholder2Keypair.publicKey - ) + ); const metaplex = Metaplex.make(anchor.getProvider().connection) .use(keypairIdentity(appAuthorityKeypair)) - .use(mockStorage()) + .use(mockStorage()); const userMetaAddress = userAccountKeyFromPubkey( appAuthorityKeypair.publicKey - ) + ); // create user meta -- required by the subscription program's createApp instruction const createUserMetaIx = await subscriptionProgram.methods @@ -135,22 +139,22 @@ describe("referrals", () => { auth: appAuthorityKeypair.publicKey, systemProgram: SystemProgram.programId, }) - .instruction() + .instruction(); // create an app - const appId = 1 + const appId = 1; const [appAddress] = findAppAddress( appAuthorityKeypair.publicKey, appId, subscriptionProgram.programId - ) + ); const [referralshipTreasuryAddress] = findReferralshipTreasuryAccountAddress( appAddress, treasuryMint, referralProgram.programId - ) + ); const createAppIx = await subscriptionProgram.methods .createApp(appId, "super app") @@ -162,15 +166,15 @@ describe("referrals", () => { treasury: referralshipTreasuryAddress, systemProgram: SystemProgram.programId, }) - .instruction() + .instruction(); const tierArgs = { name: "basic", id: 1, price: 100, interval: { month: {} }, // monthly - } - const tierAddress = tierAccountKey(appAddress, 1) + }; + const tierAddress = tierAccountKey(appAddress, 1); const createTierIx = await subscriptionProgram.methods .createTier( @@ -185,23 +189,23 @@ describe("referrals", () => { signer: appAuthorityKeypair.publicKey, systemProgram: SystemProgram.programId, }) - .instruction() + .instruction(); const createUserAndAppTx = new Transaction() .add(createUserMetaIx) .add(createAppIx) - .add(createTierIx) + .add(createTierIx); await anchor .getProvider() .sendAndConfirm(createUserAndAppTx, [appAuthorityKeypair], { skipPreflight: true, - }) + }); const [referralshipAddress] = findReferralshipAddress( appAddress, referralProgram.programId - ) + ); const referralAgentsCollectionNFT = await metaplex.nfts().create({ name: "Referral Agents", @@ -210,7 +214,7 @@ describe("referrals", () => { sellerFeeBasisPoints: 0, isCollection: true, collectionAuthority: appAuthorityKeypair, - }) + }); const referralAgentNFT = await metaplex.nfts().create({ name: "Referral Agent", @@ -220,7 +224,7 @@ describe("referrals", () => { collection: referralAgentsCollectionNFT.mintAddress, collectionAuthority: appAuthorityKeypair, tokenOwner: referralAgentKeypair.publicKey, - }) + }); // create a referralship account const createReferralshipIx = await referralProgram.methods @@ -240,39 +244,39 @@ describe("referrals", () => { plegeProgram: subscriptionProgram.programId, systemProgram: SystemProgram.programId, }) - .instruction() + .instruction(); - const createReferralshipTx = new Transaction().add(createReferralshipIx) + const createReferralshipTx = new Transaction().add(createReferralshipIx); await anchor .getProvider() .sendAndConfirm(createReferralshipTx, [appAuthorityKeypair], { skipPreflight: true, - }) + }); const referralship = await referralProgram.account.referralship.fetch( referralshipAddress - ) + ); - assert.equal(referralship.appId, appId) - assert.equal(referralship.app.toBase58(), appAddress.toBase58()) - assert.equal(referralship.treasuryMint.toBase58(), treasuryMint.toBase58()) + assert.equal(referralship.appId, appId); + assert.equal(referralship.app.toBase58(), appAddress.toBase58()); + assert.equal(referralship.treasuryMint.toBase58(), treasuryMint.toBase58()); const [subscriptionAddress] = findSubscriptionAddress( subscriberKeypair.publicKey, appAddress, subscriptionProgram.programId - ) + ); const [referralAddress] = findReferralAddress( appAddress, subscriptionAddress, referralAgentNFT.mintAddress, referralProgram.programId - ) + ); - let treasuryInitialBalance = 100_000_000 - let subscriberInitialBalance = 100_000_000 + let treasuryInitialBalance = 100_000_000; + let subscriberInitialBalance = 100_000_000; await mintTo( connection, @@ -281,7 +285,7 @@ describe("referrals", () => { subscriberTokenAccount, treasuryAuthorityKeypair, subscriberInitialBalance - ) + ); await mintTo( connection, @@ -290,7 +294,7 @@ describe("referrals", () => { referralshipTreasuryAddress, treasuryAuthorityKeypair, treasuryInitialBalance - ) + ); const subscribeWithReferralIx = await referralProgram.methods .subscribeWithReferral() @@ -313,17 +317,17 @@ describe("referrals", () => { tokenProgram: TOKEN_PROGRAM_ID, systemProgram: SystemProgram.programId, }) - .instruction() + .instruction(); const subscribeWithReferralTx = new Transaction().add( subscribeWithReferralIx - ) + ); await anchor .getProvider() .sendAndConfirm(subscribeWithReferralTx, [subscriberKeypair], { skipPreflight: true, - }) + }); let ixAccounts = { app: appAddress, @@ -343,10 +347,10 @@ describe("referrals", () => { treasuryTokenAccount: referralshipTreasuryAddress, treasuryAuthority: treasuryAuthorityKeypair.publicKey, tokenProgram: TOKEN_PROGRAM_ID, - } + }; for (let account in ixAccounts) { - console.log(account, ixAccounts[account].toBase58()) + console.log(account, ixAccounts[account].toBase58()); } // simulate a call from the subscription program to split payments @@ -385,11 +389,11 @@ describe("referrals", () => { isSigner: false, }, ]) - .instruction() + .instruction(); - let splitTx = new Transaction().add(splitIx) + let splitTx = new Transaction().add(splitIx); await anchor.getProvider().sendAndConfirm(splitTx, [], { skipPreflight: true, - }) - }) -}) + }); + }); +}); diff --git a/tests/subscriptions.ts b/tests/subscriptions.ts index a76346c..aa742df 100644 --- a/tests/subscriptions.ts +++ b/tests/subscriptions.ts @@ -2,21 +2,21 @@ import { createAssociatedTokenAccount, getAccount, mintToChecked, -} from "@solana/spl-token" -import chaiAsPromised from "chai-as-promised" -import chai from "chai" +} from "@solana/spl-token"; +import chaiAsPromised from "chai-as-promised"; +import chai from "chai"; import { cancelSubscription, completePayment, createGeneralScaffolding, createSubscription, THREAD_PROGRAM, -} from "./utils/basic-functions" -import generateFundedKeypair from "./utils/keypair" -import { web3 } from "@project-serum/anchor" +} from "./utils/basic-functions"; +import generateFundedKeypair from "./utils/keypair"; +import { web3 } from "@project-serum/anchor"; -chai.use(chaiAsPromised) -const expect = chai.expect +chai.use(chaiAsPromised); +const expect = chai.expect; describe("subscription functionality", () => { it("subscriber can't switch tiers before paying", async () => { @@ -25,7 +25,7 @@ describe("subscription functionality", () => { tier1, subscriber1, subscriber1Ata - ) + ); await expect( global.program.methods @@ -34,6 +34,7 @@ describe("subscription functionality", () => { oldTier: tier1, newTier: tier2, app, + subscription, subscriber: subscriber1.publicKey, subscriberAta: subscriber1Ata, subscriptionThread: subscriptionThread, @@ -41,8 +42,8 @@ describe("subscription functionality", () => { }) .signers([subscriber1]) .rpc() - ).to.eventually.be.rejected - }) + ).to.eventually.be.rejected; + }); it("subscriber can switch tier after paying", async () => { const { subscription, subscriptionThread } = await createSubscription( @@ -50,16 +51,22 @@ describe("subscription functionality", () => { tier1, subscriber1, subscriber1Ata - ) + ); let destination = await createAssociatedTokenAccount( global.connection, auth, global.mint, auth.publicKey - ) + ); - await completePayment(app, tier1, destination, subscriber1Ata, subscription) + await completePayment( + app, + tier1, + destination, + subscriber1Ata, + subscription + ); await global.program.methods .switchSubscriptionTier() @@ -73,11 +80,11 @@ describe("subscription functionality", () => { threadProgram: THREAD_PROGRAM, }) .signers([subscriber1]) - .rpc() + .rpc(); - const sub = await global.program.account.subscription.fetch(subscription) - expect(sub.tier.toBase58()).to.equal(tier2.toBase58()) - }) + const sub = await global.program.account.subscription.fetch(subscription); + expect(sub.tier.toBase58()).to.equal(tier2.toBase58()); + }); it("switching tiers credits unused balance to new tier", async () => { const { subscription, subscriptionThread } = await createSubscription( @@ -85,16 +92,22 @@ describe("subscription functionality", () => { tier1, subscriber1, subscriber1Ata - ) + ); let destination = await createAssociatedTokenAccount( global.connection, auth, global.mint, auth.publicKey - ) + ); - await completePayment(app, tier1, destination, subscriber1Ata, subscription) + await completePayment( + app, + tier1, + destination, + subscriber1Ata, + subscription + ); await global.program.methods .switchSubscriptionTier() @@ -108,33 +121,37 @@ describe("subscription functionality", () => { threadProgram: THREAD_PROGRAM, }) .signers([subscriber1]) - .rpc() - - await completePayment(app, tier2, destination, subscriber1Ata, subscription) - - const destinationAta = await getAccount(global.connection, destination) - expect(Number(destinationAta.amount)).to.equal(10) - }) - - it("subscription can be closed if inactive", async () => { - let subscription, subscriptionThread, subscriptionBump - ;({ subscription, subscriptionThread, subscriptionBump } = - await createSubscription(app, tier1, subscriber1, subscriber1Ata)) - - await cancelSubscription(app, tier1, subscriber1, subscriber1Ata) + .rpc(); - await global.program.methods - .closeSubscriptionAccount(subscriptionBump) - .accounts({ - app, - subscription, - subscriber: subscriber1.publicKey, - subscriptionThread, - threadProgram: THREAD_PROGRAM, - }) - .signers([subscriber1]) - .rpc() - }) + await completePayment( + app, + tier2, + destination, + subscriber1Ata, + subscription + ); + + const destinationAta = await getAccount(global.connection, destination); + expect(Number(destinationAta.amount)).to.equal(10); + }); + + // it("subscription can be closed if inactive", async () => { + // let subscription, subscriptionThread, subscriptionBump; + // ({ subscription, subscriptionThread, subscriptionBump } = + // await createSubscription(app, tier1, subscriber1, subscriber1Ata)); + + // await cancelSubscription(app, tier1, subscriber1, subscriber1Ata); + + // await global.program.methods + // .closeSubscriptionAccount(subscriptionBump) + // .accounts({ + // app, + // subscriber: subscriber1.publicKey, + // subscription, + // }) + // .signers([subscriber1]) + // .rpc(); + // }); let user, app, @@ -144,34 +161,34 @@ describe("subscription functionality", () => { subscriber1, subscriber1Ata, subscriber2, - subscriber2Ata + subscriber2Ata; beforeEach(async () => { - ;({ user, app, tier1, tier2, auth } = await createGeneralScaffolding()) - let subscriber = await generateFundedKeypair(global.connection) - subscriber1 = await generateFundedKeypair(global.connection) - subscriber2 = await generateFundedKeypair(global.connection) + ({ user, app, tier1, tier2, auth } = await createGeneralScaffolding()); + let subscriber = await generateFundedKeypair(global.connection); + subscriber1 = await generateFundedKeypair(global.connection); + subscriber2 = await generateFundedKeypair(global.connection); let subscriberAta = await createAssociatedTokenAccount( global.connection, subscriber, global.mint, subscriber.publicKey - ) + ); subscriber1Ata = await createAssociatedTokenAccount( global.connection, subscriber1, global.mint, subscriber1.publicKey - ) + ); subscriber2Ata = await createAssociatedTokenAccount( global.connection, subscriber2, global.mint, subscriber2.publicKey - ) + ); await mintToChecked( global.connection, @@ -181,7 +198,7 @@ describe("subscription functionality", () => { global.testKeypairs.colossal.publicKey, 1000 * 10 ** 5, 5 - ) + ); await mintToChecked( global.connection, @@ -191,7 +208,7 @@ describe("subscription functionality", () => { global.testKeypairs.colossal.publicKey, 1000 * 10 ** 5, 5 - ) + ); await mintToChecked( global.connection, @@ -201,13 +218,13 @@ describe("subscription functionality", () => { global.testKeypairs.colossal.publicKey, 1000 * 10 ** 5, 5 - ) + ); const { subscription, subscriptionThread } = await createSubscription( app, tier1, subscriber, subscriberAta - ) - }) -}) + ); + }); +}); diff --git a/tests/tiers.ts b/tests/tiers.ts index ace4baf..0b762f6 100644 --- a/tests/tiers.ts +++ b/tests/tiers.ts @@ -1,39 +1,39 @@ -import { createAssociatedTokenAccount, mintToChecked } from "@solana/spl-token" -import { expect } from "chai" +import { createAssociatedTokenAccount, mintToChecked } from "@solana/spl-token"; +import { expect } from "chai"; import { completePayment, createGeneralScaffolding, createSubscription, subscriptionAccountKey, -} from "./utils/basic-functions" -import generateFundedKeypair from "./utils/keypair" +} from "./utils/basic-functions"; +import generateFundedKeypair from "./utils/keypair"; -xdescribe("tier functionality", () => { +describe("tier functionality", () => { it("new tier accepts subscribers", async () => { const { subscription: subscription1 } = await createSubscription( app, tier1, subscriber1, subscriber1Ata - ) + ); const { subscription: subscription2 } = await createSubscription( app, tier1, subscriber2, subscriber2Ata - ) + ); const subscription1PDA = await global.program.account.subscription.fetch( subscription1 - ) + ); const subscription2PDA = await global.program.account.subscription.fetch( subscription2 - ) + ); - expect(subscription1PDA) - expect(subscription2PDA) - }) + expect(subscription1PDA); + expect(subscription2PDA); + }); it("tier can stop accepting subscribers", async () => { await global.program.methods @@ -44,14 +44,14 @@ xdescribe("tier functionality", () => { auth: auth.publicKey, }) .signers([auth]) - .rpc() + .rpc(); try { - await createSubscription(app, tier1, subscriber2, subscriber2Ata) + await createSubscription(app, tier1, subscriber2, subscriber2Ata); } catch (error) { - expect(error.error.errorCode.number).to.equal(2003) + expect(error.error.errorCode.number).to.equal(2003); } - }) + }); it("tier can accept subscribers again", async () => { await global.program.methods @@ -62,27 +62,27 @@ xdescribe("tier functionality", () => { auth: auth.publicKey, }) .signers([auth]) - .rpc() + .rpc(); await global.program.methods .allowNewSubscribers() .accounts({ app, tier: tier1, auth: auth.publicKey }) .signers([auth]) - .rpc() + .rpc(); const { subscription: subscription1 } = await createSubscription( app, tier1, subscriber1, subscriber1Ata - ) + ); const subscription1PDA = await global.program.account.subscription.fetch( subscription1 - ) + ); - expect(subscription1PDA) - }) + expect(subscription1PDA); + }); it("disabled tier cannot add subscribers", async () => { await global.program.methods @@ -93,14 +93,14 @@ xdescribe("tier functionality", () => { auth: auth.publicKey, }) .signers([auth]) - .rpc() + .rpc(); try { - await createSubscription(app, tier1, subscriber2, subscriber2Ata) + await createSubscription(app, tier1, subscriber2, subscriber2Ata); } catch (error) { - expect(error.error.errorCode.number).to.equal(2003) + expect(error.error.errorCode.number).to.equal(2003); } - }) + }); it("disabling a tier stops future payments", async () => { const { subscription: subscription1 } = await createSubscription( @@ -108,7 +108,7 @@ xdescribe("tier functionality", () => { tier1, subscriber1, subscriber1Ata - ) + ); await global.program.methods .disableTier() @@ -118,14 +118,14 @@ xdescribe("tier functionality", () => { auth: auth.publicKey, }) .signers([auth]) - .rpc() + .rpc(); let destination = await createAssociatedTokenAccount( global.connection, auth, global.mint, auth.publicKey - ) + ); try { await completePayment( @@ -134,11 +134,11 @@ xdescribe("tier functionality", () => { destination, subscriber1Ata, subscription1 - ) + ); } catch (error) { - expect(error.error.errorCode.number).to.equal(2003) + expect(error.error.errorCode.number).to.equal(2003); } - }) + }); let user, app, @@ -147,34 +147,34 @@ xdescribe("tier functionality", () => { subscriber1, subscriber1Ata, subscriber2, - subscriber2Ata + subscriber2Ata; beforeEach(async () => { - ;({ user, app, tier1, auth } = await createGeneralScaffolding()) - let subscriber = await generateFundedKeypair(global.connection) - subscriber1 = await generateFundedKeypair(global.connection) - subscriber2 = await generateFundedKeypair(global.connection) + ({ user, app, tier1, auth } = await createGeneralScaffolding()); + let subscriber = await generateFundedKeypair(global.connection); + subscriber1 = await generateFundedKeypair(global.connection); + subscriber2 = await generateFundedKeypair(global.connection); let subscriberAta = await createAssociatedTokenAccount( global.connection, subscriber, global.mint, subscriber.publicKey - ) + ); subscriber1Ata = await createAssociatedTokenAccount( global.connection, subscriber1, global.mint, subscriber1.publicKey - ) + ); subscriber2Ata = await createAssociatedTokenAccount( global.connection, subscriber2, global.mint, subscriber2.publicKey - ) + ); await mintToChecked( global.connection, @@ -184,7 +184,7 @@ xdescribe("tier functionality", () => { global.testKeypairs.colossal.publicKey, 1000 * 10 ** 5, 5 - ) + ); await mintToChecked( global.connection, @@ -194,7 +194,7 @@ xdescribe("tier functionality", () => { global.testKeypairs.colossal.publicKey, 1000 * 10 ** 5, 5 - ) + ); await mintToChecked( global.connection, @@ -204,8 +204,8 @@ xdescribe("tier functionality", () => { global.testKeypairs.colossal.publicKey, 1000 * 10 ** 5, 5 - ) + ); - await createSubscription(app, tier1, subscriber, subscriberAta) - }) -}) + await createSubscription(app, tier1, subscriber, subscriberAta); + }); +}); diff --git a/tests/utils/airdrop.ts b/tests/utils/airdrop.ts index 403d8e8..e39e7d8 100644 --- a/tests/utils/airdrop.ts +++ b/tests/utils/airdrop.ts @@ -1,4 +1,4 @@ -import { web3 } from "@project-serum/anchor" +import { web3 } from "@project-serum/anchor"; export default async function dispurseFunds( connection: web3.Connection, @@ -6,49 +6,53 @@ export default async function dispurseFunds( solAmount: number ) { if (solAmount > 1) { - throw "Cannot disburse more than 0.5 SOL" + throw "Cannot disburse more than 0.5 SOL"; } - let treasury = global.treasury + await connection.confirmTransaction( + await connection.requestAirdrop(recipient, web3.LAMPORTS_PER_SOL * 0.5) + ); - if (!treasury) { - treasury = web3.Keypair.generate() - global.treasury = treasury - // console.log(`Set treasury to ${treasury.publicKey.toBase58()}`) - } + // let treasury = global.treasury - const balance = await connection.getBalance(treasury.publicKey) - // console.log(`Current treasury balance is ${balance} lamports`) - if (balance < web3.LAMPORTS_PER_SOL * 0.5) { - // console.log("Airdropping 2 SOL to treasury") - const sig = await connection.requestAirdrop( - treasury.publicKey, - web3.LAMPORTS_PER_SOL * 2 - ) - - const latestBlockHash = await connection.getLatestBlockhash() - await connection.confirmTransaction({ - blockhash: latestBlockHash.blockhash, - lastValidBlockHeight: latestBlockHash.lastValidBlockHeight, - signature: sig, - }) - - const newBalance = await connection.getBalance(treasury.publicKey) - // console.log(`New treasury balance is ${newBalance} lamports`) - } + // if (!treasury) { + // treasury = web3.Keypair.generate() + // global.treasury = treasury + // console.log(`Set treasury to ${treasury.publicKey.toBase58()}`) + // } + + // const balance = await connection.getBalance(treasury.publicKey) + // // console.log(`Current treasury balance is ${balance} lamports`) + // if (balance < web3.LAMPORTS_PER_SOL * 0.5) { + // // console.log("Airdropping 2 SOL to treasury") + // const sig = await connection.requestAirdrop( + // treasury.publicKey, + // web3.LAMPORTS_PER_SOL * 2 + // ) + + // const latestBlockHash = await connection.getLatestBlockhash() + // await connection.confirmTransaction({ + // blockhash: latestBlockHash.blockhash, + // lastValidBlockHeight: latestBlockHash.lastValidBlockHeight, + // signature: sig, + // }) + + // const newBalance = await connection.getBalance(treasury.publicKey) + // // console.log(`New treasury balance is ${newBalance} lamports`) + // } - // console.log( - // `Sending ${solAmount} SOL from treasury ${treasury.publicKey.toBase58()} to recipient ${recipient.toBase58()}` + // // console.log( + // // `Sending ${solAmount} SOL from treasury ${treasury.publicKey.toBase58()} to recipient ${recipient.toBase58()}` + // // ) + // await web3.sendAndConfirmTransaction( + // connection, + // new web3.Transaction().add( + // web3.SystemProgram.transfer({ + // fromPubkey: treasury.publicKey, + // toPubkey: recipient, + // lamports: solAmount * web3.LAMPORTS_PER_SOL, + // }) + // ), + // [treasury] // ) - await web3.sendAndConfirmTransaction( - connection, - new web3.Transaction().add( - web3.SystemProgram.transfer({ - fromPubkey: treasury.publicKey, - toPubkey: recipient, - lamports: solAmount * web3.LAMPORTS_PER_SOL, - }) - ), - [treasury] - ) } diff --git a/tests/utils/basic-functions.ts b/tests/utils/basic-functions.ts index 0ee3ff9..afccd81 100644 --- a/tests/utils/basic-functions.ts +++ b/tests/utils/basic-functions.ts @@ -1,5 +1,5 @@ -import { BN, web3 } from "@project-serum/anchor" -import generateFundedKeypair from "./keypair" +import { BN, web3 } from "@project-serum/anchor"; +import generateFundedKeypair from "./keypair"; export function userAccountKeyFromPubkey( pubkey: web3.PublicKey @@ -7,14 +7,14 @@ export function userAccountKeyFromPubkey( return web3.PublicKey.findProgramAddressSync( [Buffer.from("USER_META"), pubkey.toBuffer()], global.program.programId - )[0] + )[0]; } export function findUserMetaAddress(pubkey: web3.PublicKey) { return web3.PublicKey.findProgramAddressSync( [Buffer.from("USER_META"), pubkey.toBuffer()], global.program.programId - ) + ); } export function appAccountKey( @@ -28,7 +28,7 @@ export function appAccountKey( new BN(appId).toArrayLike(Buffer, "be", 1), ], global.program.programId - )[0] + )[0]; } export function findAppAddress( @@ -43,11 +43,11 @@ export function findAppAddress( new BN(appId).toArrayLike(Buffer, "be", 1), ], programId - ) + ); } export function numberToAppId(appId: number): Buffer { - return new BN(appId).toArrayLike(Buffer, "be", 1) + return new BN(appId).toArrayLike(Buffer, "be", 1); } export function tierAccountKey( @@ -61,7 +61,7 @@ export function tierAccountKey( new BN(tierId).toArrayLike(Buffer, "be", 1), ], global.program.programId - )[0] + )[0]; } export function subscriptionAccountKey( @@ -71,7 +71,7 @@ export function subscriptionAccountKey( return web3.PublicKey.findProgramAddressSync( [Buffer.from("SUBSCRIPTION"), app.toBuffer(), subscriber.toBuffer()], global.program.programId - ) + ); } export function subscriptionThreadKey( @@ -84,7 +84,7 @@ export function subscriptionThreadKey( Buffer.from("subscriber_thread"), ], THREAD_PROGRAM - )[0] + )[0]; } export function findSubscriptionAddress( @@ -95,27 +95,27 @@ export function findSubscriptionAddress( return web3.PublicKey.findProgramAddressSync( [Buffer.from("SUBSCRIPTION"), app.toBuffer(), subscriber.toBuffer()], programId - ) + ); } export async function createGeneralScaffolding(): Promise<{ - user - app - tier1 - tier2 - tier3 - tier4 - auth + user; + app; + tier1; + tier2; + tier3; + tier4; + auth; }> { - const auth = await generateFundedKeypair(global.connection) - const user = userAccountKeyFromPubkey(auth.publicKey) - const app = appAccountKey(auth.publicKey, 1) - const tier1 = tierAccountKey(app, 1) - const tier2 = tierAccountKey(app, 2) - const tier3 = tierAccountKey(app, 3) - const tier4 = tierAccountKey(app, 4) + const auth = await generateFundedKeypair(global.connection); + const user = userAccountKeyFromPubkey(auth.publicKey); + const app = appAccountKey(auth.publicKey, 1); + const tier1 = tierAccountKey(app, 1); + const tier2 = tierAccountKey(app, 2); + const tier3 = tierAccountKey(app, 3); + const tier4 = tierAccountKey(app, 4); - const transaction = new web3.Transaction() + const transaction = new web3.Transaction(); transaction.add( await global.program.methods .createUser() @@ -170,17 +170,17 @@ export async function createGeneralScaffolding(): Promise<{ }) .signers([auth]) .instruction() - ) + ); - const sig = await global.connection.sendTransaction(transaction, [auth]) + const sig = await global.connection.sendTransaction(transaction, [auth]); - const latestBlockHash = await global.connection.getLatestBlockhash() + const latestBlockHash = await global.connection.getLatestBlockhash(); await global.connection.confirmTransaction({ blockhash: latestBlockHash.blockhash, lastValidBlockHeight: latestBlockHash.lastValidBlockHeight, signature: sig, - }) + }); return { auth, @@ -190,7 +190,7 @@ export async function createGeneralScaffolding(): Promise<{ tier2, tier3, tier4, - } + }; } export async function createSubscription( @@ -199,16 +199,16 @@ export async function createSubscription( subscriber: web3.Keypair, subscriberAta: web3.PublicKey ): Promise<{ - subscription: any - subscriptionThread: any - subscriptionBump: number + subscription: any; + subscriptionThread: any; + subscriptionBump: number; }> { let [subscription, subscriptionBump] = subscriptionAccountKey( subscriber.publicKey, app - ) + ); - let thread = subscriptionThreadKey(subscription) + let thread = subscriptionThreadKey(subscription); await global.program.methods .createSubscription() @@ -221,14 +221,14 @@ export async function createSubscription( subscriberAta, }) .signers([subscriber]) - .rpc() + .rpc(); - return { subscription, subscriptionThread: thread, subscriptionBump } + return { subscription, subscriptionThread: thread, subscriptionBump }; } export const THREAD_PROGRAM = new web3.PublicKey( "3XXuUFfweXBwFgFfYaejLvZE4cGZiHgKiGfMtdxNzYmv" -) +); export async function cancelSubscription( app: web3.PublicKey, @@ -236,21 +236,19 @@ export async function cancelSubscription( subscriber: web3.Keypair, subscriberAta: web3.PublicKey ) { - let [subscription] = subscriptionAccountKey(subscriber.publicKey, app) - let thread = subscriptionThreadKey(subscription) + let [subscription] = subscriptionAccountKey(subscriber.publicKey, app); await global.program.methods .cancelSubscription() .accounts({ app, tier, + subscription, subscriber: subscriber.publicKey, subscriberAta, - subscriptionThread: thread, - threadProgram: THREAD_PROGRAM, }) .signers([subscriber]) - .rpc() + .rpc(); } export async function completePayment( @@ -260,8 +258,6 @@ export async function completePayment( subscriberAta: web3.PublicKey, subscription: web3.PublicKey ) { - const thread = subscriptionThreadKey(subscription) - await global.program.methods .completePayment() .accounts({ @@ -270,7 +266,6 @@ export async function completePayment( destination, subscriberAta, subscription, - subscriptionThread: thread, }) - .rpc() + .rpc(); } diff --git a/tests/utils/globalSetup.ts b/tests/utils/globalSetup.ts index a10de1f..0a25fb1 100644 --- a/tests/utils/globalSetup.ts +++ b/tests/utils/globalSetup.ts @@ -1,33 +1,33 @@ -import { Program, web3 } from "@project-serum/anchor" -import * as anchor from "@project-serum/anchor" -import { Plege } from "../../target/types/plege" -import generateFundedKeypair from "./keypair" -import { createMint } from "@solana/spl-token" +import { Program, web3 } from "@project-serum/anchor"; +import * as anchor from "@project-serum/anchor"; +import { Plege } from "../../target/types/plege"; +import generateFundedKeypair from "./keypair"; +import { createMint } from "@solana/spl-token"; -var connection: web3.Connection -var program -var connection: web3.Connection +var connection: web3.Connection; +var program; +var connection: web3.Connection; exports.mochaGlobalSetup = async function () { - anchor.setProvider(anchor.AnchorProvider.env()) - program = anchor.workspace.Plege as Program - connection = program.provider.connection - global.program = program - global.connection = connection - await setTestKeypairs() + anchor.setProvider(anchor.AnchorProvider.env()); + program = anchor.workspace.Plege as Program; + connection = program.provider.connection; + global.program = program; + global.connection = connection; + await setTestKeypairs(); global.mint = await createMint( global.connection, global.testKeypairs.colossal, global.testKeypairs.colossal.publicKey, global.testKeypairs.colossal.publicKey, 5 - ) -} + ); +}; async function setTestKeypairs() { global.testKeypairs = { colossal: await generateFundedKeypair(connection), - // subscriber: await generateFundedKeypair(connection), //keypairs[1], - // hacker: await generateFundedKeypair(connection), //keypairs[2], - } + subscriber: await generateFundedKeypair(connection), //keypairs[1], + hacker: await generateFundedKeypair(connection), //keypairs[2], + }; }