From d51d4d996fb863925e94fb1a31d5fca8bab3678b Mon Sep 17 00:00:00 2001 From: 0xFirekeeper <0xFirekeeper@gmail.com> Date: Fri, 11 Sep 2026 01:40:34 +0700 Subject: [PATCH] [SDK] Skip flaky tests Co-Authored-By: Claude Fable 5.1 --- .../src/contract/actions/resolve-abi.test.ts | 8 +- .../write/airdropERC721WithSignature.test.ts | 9 +- .../src/extensions/erc1155/drop1155.test.ts | 2 +- .../erc1155/write/sigMint1155.test.ts | 376 +++++++++--------- .../src/extensions/erc20/drop20.test.ts | 2 +- .../erc721/write/sigMint721.test.ts | 10 +- .../ClaimableERC1155/claimableERC1155.test.ts | 358 ++++++++--------- .../ClaimableERC20/claimableERC20.test.ts | 2 +- .../ClaimableERC721/claimableERC721.test.ts | 2 +- .../prebuilts/process-ref-deployments.test.ts | 2 +- 10 files changed, 385 insertions(+), 386 deletions(-) diff --git a/packages/thirdweb/src/contract/actions/resolve-abi.test.ts b/packages/thirdweb/src/contract/actions/resolve-abi.test.ts index da222575e66..21d5c3927e2 100644 --- a/packages/thirdweb/src/contract/actions/resolve-abi.test.ts +++ b/packages/thirdweb/src/contract/actions/resolve-abi.test.ts @@ -43,15 +43,13 @@ it("should resolve abi from contract api", async () => { expect(abi).toMatchObject(DOODLES_ABI); }); -it.runIf(process.env.TW_SECRET_KEY)( - "should resolve abi from bytecode", - async () => { +it.runIf(process.env.TW_SECRET_KEY) + .skip("should resolve abi from bytecode", async () => { // we do this so we don't hit any PRIOR cache const DOODLES_CONTRACT_CLONE = { ...DOODLES_CONTRACT }; const abi = await resolveAbiFromBytecode(DOODLES_CONTRACT_CLONE); expect(abi).toMatchObject(DOODLES_ABI); - }, -); + }); it("should throw error if contract bytecode is 0x", async () => { const wrongContract = getContract({ diff --git a/packages/thirdweb/src/extensions/airdrop/write/airdropERC721WithSignature.test.ts b/packages/thirdweb/src/extensions/airdrop/write/airdropERC721WithSignature.test.ts index c4add6c8105..262686e596c 100644 --- a/packages/thirdweb/src/extensions/airdrop/write/airdropERC721WithSignature.test.ts +++ b/packages/thirdweb/src/extensions/airdrop/write/airdropERC721WithSignature.test.ts @@ -26,9 +26,9 @@ import { // skip this test suite if there is no secret key available to test with // TODO: remove reliance on secret key during unit tests entirely -describe.runIf(process.env.TW_SECRET_KEY)( - "generateAirdropSignatureERC721", - () => { +describe + .runIf(process.env.TW_SECRET_KEY) + .skip("generateAirdropSignatureERC721", () => { let airdropContract: ThirdwebContract; let erc721TokenContract: ThirdwebContract; @@ -158,5 +158,4 @@ describe.runIf(process.env.TW_SECRET_KEY)( expect(transactionHash.length).toBe(66); }); - }, -); + }); diff --git a/packages/thirdweb/src/extensions/erc1155/drop1155.test.ts b/packages/thirdweb/src/extensions/erc1155/drop1155.test.ts index 6d2b9655f00..e68f8a8673a 100644 --- a/packages/thirdweb/src/extensions/erc1155/drop1155.test.ts +++ b/packages/thirdweb/src/extensions/erc1155/drop1155.test.ts @@ -31,7 +31,7 @@ import { getNFT } from "./read/getNFT.js"; import { isGetNFTsSupported } from "./read/getNFTs.js"; import { lazyMint } from "./write/lazyMint.js"; -describe.runIf(process.env.TW_SECRET_KEY)( +describe.runIf(process.env.TW_SECRET_KEY).skip( "DropERC1155", { retry: 0, diff --git a/packages/thirdweb/src/extensions/erc1155/write/sigMint1155.test.ts b/packages/thirdweb/src/extensions/erc1155/write/sigMint1155.test.ts index 15ab9956562..ba18907f3a7 100644 --- a/packages/thirdweb/src/extensions/erc1155/write/sigMint1155.test.ts +++ b/packages/thirdweb/src/extensions/erc1155/write/sigMint1155.test.ts @@ -20,212 +20,214 @@ import { generateMintSignature, mintWithSignature } from "./sigMint.js"; // skip this test suite if there is no secret key available to test with // TODO: remove reliance on secret key during unit tests entirely -describe.runIf(process.env.TW_SECRET_KEY)("generateMintSignature1155", () => { - let erc1155Contract: ThirdwebContract; - let erc20TokenContract: ThirdwebContract; +describe + .runIf(process.env.TW_SECRET_KEY) + .skip("generateMintSignature1155", () => { + let erc1155Contract: ThirdwebContract; + let erc20TokenContract: ThirdwebContract; - beforeAll(async () => { - erc1155Contract = getContract({ - address: await deployERC1155Contract({ - account: TEST_ACCOUNT_A, + beforeAll(async () => { + erc1155Contract = getContract({ + address: await deployERC1155Contract({ + account: TEST_ACCOUNT_A, + chain: ANVIL_CHAIN, + client: TEST_CLIENT, + params: { + name: "Test", + symbol: "TST", + }, + type: "TokenERC1155", + }), chain: ANVIL_CHAIN, client: TEST_CLIENT, - params: { - name: "Test", - symbol: "TST", - }, - type: "TokenERC1155", - }), - chain: ANVIL_CHAIN, - client: TEST_CLIENT, - }); + }); - erc20TokenContract = getContract({ - address: await deployERC20Contract({ - account: TEST_ACCOUNT_A, + erc20TokenContract = getContract({ + address: await deployERC20Contract({ + account: TEST_ACCOUNT_A, + chain: ANVIL_CHAIN, + client: TEST_CLIENT, + params: { + name: "TestToken", + symbol: "TSTT", + }, + type: "TokenERC20", + }), chain: ANVIL_CHAIN, client: TEST_CLIENT, - params: { - name: "TestToken", - symbol: "TSTT", - }, - type: "TokenERC20", - }), - chain: ANVIL_CHAIN, - client: TEST_CLIENT, - }); - }, 60000); + }); + }, 60000); - it("should generate a mint signature and mint an NFT", async () => { - const { payload, signature } = await generateMintSignature({ - account: TEST_ACCOUNT_A, - contract: erc1155Contract, - mintRequest: { - metadata: { - description: "This is my NFT", - image: "https://example.com/image.png", - name: "My NFT", + it("should generate a mint signature and mint an NFT", async () => { + const { payload, signature } = await generateMintSignature({ + account: TEST_ACCOUNT_A, + contract: erc1155Contract, + mintRequest: { + metadata: { + description: "This is my NFT", + image: "https://example.com/image.png", + name: "My NFT", + }, + pricePerToken: "0.1", + quantity: 10n, + to: TEST_ACCOUNT_B.address, }, - pricePerToken: "0.1", - quantity: 10n, - to: TEST_ACCOUNT_B.address, - }, - }); - const transaction = mintWithSignature({ - contract: erc1155Contract, - payload, - signature, - }); - const { transactionHash } = await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_A, - transaction, - }); - expect(transactionHash.length).toBe(66); - const nft = await getNFT({ - contract: erc1155Contract, - tokenId: 0n, + }); + const transaction = mintWithSignature({ + contract: erc1155Contract, + payload, + signature, + }); + const { transactionHash } = await sendAndConfirmTransaction({ + account: TEST_ACCOUNT_A, + transaction, + }); + expect(transactionHash.length).toBe(66); + const nft = await getNFT({ + contract: erc1155Contract, + tokenId: 0n, + }); + if (nft.type !== "ERC1155") throw new Error("Expected ERC1155 NFT"); + expect(nft.id).toBe(0n); + expect(nft.supply).toBe(10n); + expect(nft.metadata.name).toBe("My NFT"); + expect(nft.metadata.description).toBe("This is my NFT"); }); - if (nft.type !== "ERC1155") throw new Error("Expected ERC1155 NFT"); - expect(nft.id).toBe(0n); - expect(nft.supply).toBe(10n); - expect(nft.metadata.name).toBe("My NFT"); - expect(nft.metadata.description).toBe("This is my NFT"); - }); - it("should mint additional supply", async () => { - const { payload, signature } = await generateMintSignature({ - account: TEST_ACCOUNT_A, - contract: erc1155Contract, - mintRequest: { - quantity: 5n, - to: TEST_ACCOUNT_B.address, + it("should mint additional supply", async () => { + const { payload, signature } = await generateMintSignature({ + account: TEST_ACCOUNT_A, + contract: erc1155Contract, + mintRequest: { + quantity: 5n, + to: TEST_ACCOUNT_B.address, + tokenId: 0n, + }, + }); + const transaction = mintWithSignature({ + contract: erc1155Contract, + payload, + signature, + }); + const { transactionHash } = await sendAndConfirmTransaction({ + account: TEST_ACCOUNT_A, + transaction, + }); + expect(transactionHash.length).toBe(66); + const nft = await getNFT({ + contract: erc1155Contract, tokenId: 0n, - }, - }); - const transaction = mintWithSignature({ - contract: erc1155Contract, - payload, - signature, - }); - const { transactionHash } = await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_A, - transaction, + }); + if (nft.type !== "ERC1155") throw new Error("Expected ERC1155 NFT"); + expect(nft.id).toBe(0n); + expect(nft.supply).toBe(15n); + expect(nft.metadata.name).toBe("My NFT"); + expect(nft.metadata.description).toBe("This is my NFT"); }); - expect(transactionHash.length).toBe(66); - const nft = await getNFT({ - contract: erc1155Contract, - tokenId: 0n, - }); - if (nft.type !== "ERC1155") throw new Error("Expected ERC1155 NFT"); - expect(nft.id).toBe(0n); - expect(nft.supply).toBe(15n); - expect(nft.metadata.name).toBe("My NFT"); - expect(nft.metadata.description).toBe("This is my NFT"); - }); - it("should generate a mint signature with default values", async () => { - const { payload, signature } = await generateMintSignature({ - account: TEST_ACCOUNT_A, - contract: erc1155Contract, - mintRequest: { - metadata: "https://example.com/token", - quantity: 10n, - to: TEST_ACCOUNT_B.address, - }, - }); + it("should generate a mint signature with default values", async () => { + const { payload, signature } = await generateMintSignature({ + account: TEST_ACCOUNT_A, + contract: erc1155Contract, + mintRequest: { + metadata: "https://example.com/token", + quantity: 10n, + to: TEST_ACCOUNT_B.address, + }, + }); - expect(payload.to).toBe(TEST_ACCOUNT_B.address); - expect(payload.tokenId).toBe(maxUint256); - expect(payload.royaltyRecipient).toBe(TEST_ACCOUNT_A.address); - expect(payload.royaltyBps).toBe(0n); - expect(payload.primarySaleRecipient).toBe(TEST_ACCOUNT_A.address); - expect(payload.uri).toBe("https://example.com/token"); - expect(payload.pricePerToken).toBe(0n); - expect(payload.quantity).toBe(10n); - expect(payload.currency).toBe(NATIVE_TOKEN_ADDRESS); - expect(payload.validityStartTimestamp).toBe(0n); - expect(payload.validityEndTimestamp).toBeGreaterThan(0n); - expect(payload.uid).toBeDefined(); - expect(signature.length).toBe(132); + expect(payload.to).toBe(TEST_ACCOUNT_B.address); + expect(payload.tokenId).toBe(maxUint256); + expect(payload.royaltyRecipient).toBe(TEST_ACCOUNT_A.address); + expect(payload.royaltyBps).toBe(0n); + expect(payload.primarySaleRecipient).toBe(TEST_ACCOUNT_A.address); + expect(payload.uri).toBe("https://example.com/token"); + expect(payload.pricePerToken).toBe(0n); + expect(payload.quantity).toBe(10n); + expect(payload.currency).toBe(NATIVE_TOKEN_ADDRESS); + expect(payload.validityStartTimestamp).toBe(0n); + expect(payload.validityEndTimestamp).toBeGreaterThan(0n); + expect(payload.uid).toBeDefined(); + expect(signature.length).toBe(132); - const transaction = mintWithSignature({ - contract: erc1155Contract, - payload, - signature, - }); - const { transactionHash } = await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_A, - transaction, + const transaction = mintWithSignature({ + contract: erc1155Contract, + payload, + signature, + }); + const { transactionHash } = await sendAndConfirmTransaction({ + account: TEST_ACCOUNT_A, + transaction, + }); + expect(transactionHash.length).toBe(66); }); - expect(transactionHash.length).toBe(66); - }); - it("should generate a mint signature with custom values", async () => { - const uid = toHex("abcdef1234567890", { size: 32 }); - const { payload, signature } = await generateMintSignature({ - account: TEST_ACCOUNT_A, - contract: erc1155Contract, - mintRequest: { - currency: erc20TokenContract.address, - pricePerToken: "0.2", - primarySaleRecipient: TEST_ACCOUNT_A.address, - quantity: 10n, - royaltyBps: 500, - royaltyRecipient: TEST_ACCOUNT_B.address, - to: TEST_ACCOUNT_B.address, - tokenId: 0n, - uid, - validityEndTimestamp: new Date(1867260800), - validityStartTimestamp: new Date(1635724800), - }, + it("should generate a mint signature with custom values", async () => { + const uid = toHex("abcdef1234567890", { size: 32 }); + const { payload, signature } = await generateMintSignature({ + account: TEST_ACCOUNT_A, + contract: erc1155Contract, + mintRequest: { + currency: erc20TokenContract.address, + pricePerToken: "0.2", + primarySaleRecipient: TEST_ACCOUNT_A.address, + quantity: 10n, + royaltyBps: 500, + royaltyRecipient: TEST_ACCOUNT_B.address, + to: TEST_ACCOUNT_B.address, + tokenId: 0n, + uid, + validityEndTimestamp: new Date(1867260800), + validityStartTimestamp: new Date(1635724800), + }, + }); + + expect(payload.to).toBe(TEST_ACCOUNT_B.address); + expect(payload.tokenId).toBe(0n); + expect(payload.royaltyRecipient).toBe(TEST_ACCOUNT_B.address); + expect(payload.royaltyBps).toBe(500n); + expect(payload.primarySaleRecipient).toBe(TEST_ACCOUNT_A.address); + expect(payload.uri).toBe(""); + expect(payload.pricePerToken).toBe(200000000000000000n); + expect(payload.quantity).toBe(10n); + expect(payload.currency).toBe(erc20TokenContract.address); + expect(payload.validityStartTimestamp).toBe(1635724n); + expect(payload.validityEndTimestamp).toBe(1867260n); + expect(payload.uid).toBe(uid); + expect(signature.length).toBe(132); }); - expect(payload.to).toBe(TEST_ACCOUNT_B.address); - expect(payload.tokenId).toBe(0n); - expect(payload.royaltyRecipient).toBe(TEST_ACCOUNT_B.address); - expect(payload.royaltyBps).toBe(500n); - expect(payload.primarySaleRecipient).toBe(TEST_ACCOUNT_A.address); - expect(payload.uri).toBe(""); - expect(payload.pricePerToken).toBe(200000000000000000n); - expect(payload.quantity).toBe(10n); - expect(payload.currency).toBe(erc20TokenContract.address); - expect(payload.validityStartTimestamp).toBe(1635724n); - expect(payload.validityEndTimestamp).toBe(1867260n); - expect(payload.uid).toBe(uid); - expect(signature.length).toBe(132); - }); + it("should generate a mint signature with custom values", async () => { + const { payload, signature } = await generateMintSignature({ + account: TEST_ACCOUNT_A, + contract: erc1155Contract, + mintRequest: { + currency: erc20TokenContract.address, + pricePerToken: "0.2", + primarySaleRecipient: TEST_ACCOUNT_A.address, + quantity: 10n, + royaltyBps: 500, + royaltyRecipient: TEST_ACCOUNT_B.address, + to: TEST_ACCOUNT_B.address, + tokenId: 0n, + uid: "abcdef1234567890", + validityEndTimestamp: new Date(1867260800), + validityStartTimestamp: new Date(1635724800), + }, + }); - it("should generate a mint signature with custom values", async () => { - const { payload, signature } = await generateMintSignature({ - account: TEST_ACCOUNT_A, - contract: erc1155Contract, - mintRequest: { - currency: erc20TokenContract.address, - pricePerToken: "0.2", - primarySaleRecipient: TEST_ACCOUNT_A.address, - quantity: 10n, - royaltyBps: 500, - royaltyRecipient: TEST_ACCOUNT_B.address, - to: TEST_ACCOUNT_B.address, - tokenId: 0n, - uid: "abcdef1234567890", - validityEndTimestamp: new Date(1867260800), - validityStartTimestamp: new Date(1635724800), - }, + expect(payload.to).toBe(TEST_ACCOUNT_B.address); + expect(payload.tokenId).toBe(0n); + expect(payload.royaltyRecipient).toBe(TEST_ACCOUNT_B.address); + expect(payload.royaltyBps).toBe(500n); + expect(payload.primarySaleRecipient).toBe(TEST_ACCOUNT_A.address); + expect(payload.uri).toBe(""); + expect(payload.pricePerToken).toBe(200000000000000000n); + expect(payload.quantity).toBe(10n); + expect(payload.currency).toBe(erc20TokenContract.address); + expect(payload.validityStartTimestamp).toBe(1635724n); + expect(payload.validityEndTimestamp).toBe(1867260n); + expect(payload.uid).toBe(toHex("abcdef1234567890", { size: 32 })); + expect(signature.length).toBe(132); }); - - expect(payload.to).toBe(TEST_ACCOUNT_B.address); - expect(payload.tokenId).toBe(0n); - expect(payload.royaltyRecipient).toBe(TEST_ACCOUNT_B.address); - expect(payload.royaltyBps).toBe(500n); - expect(payload.primarySaleRecipient).toBe(TEST_ACCOUNT_A.address); - expect(payload.uri).toBe(""); - expect(payload.pricePerToken).toBe(200000000000000000n); - expect(payload.quantity).toBe(10n); - expect(payload.currency).toBe(erc20TokenContract.address); - expect(payload.validityStartTimestamp).toBe(1635724n); - expect(payload.validityEndTimestamp).toBe(1867260n); - expect(payload.uid).toBe(toHex("abcdef1234567890", { size: 32 })); - expect(signature.length).toBe(132); }); -}); diff --git a/packages/thirdweb/src/extensions/erc20/drop20.test.ts b/packages/thirdweb/src/extensions/erc20/drop20.test.ts index 019319dd018..4fcb78ae3c4 100644 --- a/packages/thirdweb/src/extensions/erc20/drop20.test.ts +++ b/packages/thirdweb/src/extensions/erc20/drop20.test.ts @@ -23,7 +23,7 @@ import { getBalance } from "./read/getBalance.js"; import { getApprovalForTransaction } from "./write/getApprovalForTransaction.js"; import { mintTo } from "./write/mintTo.js"; -describe.runIf(process.env.TW_SECRET_KEY)( +describe.runIf(process.env.TW_SECRET_KEY).skip( "DropERC20", { retry: 0, diff --git a/packages/thirdweb/src/extensions/erc721/write/sigMint721.test.ts b/packages/thirdweb/src/extensions/erc721/write/sigMint721.test.ts index a8afd9e6865..e35ef0308ee 100644 --- a/packages/thirdweb/src/extensions/erc721/write/sigMint721.test.ts +++ b/packages/thirdweb/src/extensions/erc721/write/sigMint721.test.ts @@ -19,10 +19,9 @@ import { generateMintSignature, mintWithSignature } from "./sigMint.js"; // skip this test suite if there is no secret key available to test with // TODO: remove reliance on secret key during unit tests entirely -describe.runIf(process.env.TW_SECRET_KEY)( - "generateMintSignature721", - - () => { +describe + .runIf(process.env.TW_SECRET_KEY) + .skip("generateMintSignature721", () => { let erc721Contract: ThirdwebContract; let erc20TokenContract: ThirdwebContract; @@ -257,5 +256,4 @@ describe.runIf(process.env.TW_SECRET_KEY)( expect(payload.primarySaleRecipient).toBe(TEST_ACCOUNT_B.address); expect(signature.length).toBe(132); }); - }, -); + }); diff --git a/packages/thirdweb/src/extensions/modules/ClaimableERC1155/claimableERC1155.test.ts b/packages/thirdweb/src/extensions/modules/ClaimableERC1155/claimableERC1155.test.ts index 94477df1821..0f233295b41 100644 --- a/packages/thirdweb/src/extensions/modules/ClaimableERC1155/claimableERC1155.test.ts +++ b/packages/thirdweb/src/extensions/modules/ClaimableERC1155/claimableERC1155.test.ts @@ -20,234 +20,236 @@ import { getInstalledModules } from "../__generated__/IModularCore/read/getInsta import * as BatchMetadataERC1155 from "../BatchMetadataERC1155/index.js"; import * as ClaimableERC1155 from "./index.js"; -describe.runIf(process.env.TW_SECRET_KEY)("ModularClaimableERC1155", () => { - let contract: ThirdwebContract; - beforeAll(async () => { - const address = await deployModularContract({ - account: TEST_ACCOUNT_A, - chain: ANVIL_CHAIN, - client: TEST_CLIENT, - core: "ERC1155", - modules: [ - ClaimableERC1155.module({ - primarySaleRecipient: TEST_ACCOUNT_A.address, +describe + .runIf(process.env.TW_SECRET_KEY) + .skip("ModularClaimableERC1155", () => { + let contract: ThirdwebContract; + beforeAll(async () => { + const address = await deployModularContract({ + account: TEST_ACCOUNT_A, + chain: ANVIL_CHAIN, + client: TEST_CLIENT, + core: "ERC1155", + modules: [ + ClaimableERC1155.module({ + primarySaleRecipient: TEST_ACCOUNT_A.address, + }), + BatchMetadataERC1155.module(), + ], + params: { + contractURI: TEST_CONTRACT_URI, + name: "TestDropERC1155", + }, + }); + contract = getContract({ + address, + chain: ANVIL_CHAIN, + client: TEST_CLIENT, + }); + }, 120000); + + it("should have erc1155 module", async () => { + const modules = await getInstalledModules({ contract }); + expect(modules.length).toBe(2); + }); + + it("should upload metadata", async () => { + const transaction = BatchMetadataERC1155.uploadMetadata({ + contract, + metadatas: Array.from( + { length: 10 }, + (_, index) => + `ipfs://QmP4JFzBhTGvb27GnJ9eL9vZGYpNBGjHnPudWndruiNERm/${index}`, + ), + }); + + await sendAndConfirmTransaction({ + account: TEST_ACCOUNT_A, + transaction, + }); + }); + + it("should not claim without claim conditions", async () => { + // should throw + await expect( + sendAndConfirmTransaction({ + account: TEST_ACCOUNT_A, + transaction: ClaimableERC1155.mint({ + contract, + quantity: 1, + to: TEST_ACCOUNT_A.address, + tokenId: 123123123213n, + }), }), - BatchMetadataERC1155.module(), - ], - params: { - contractURI: TEST_CONTRACT_URI, - name: "TestDropERC1155", - }, - }); - contract = getContract({ - address, - chain: ANVIL_CHAIN, - client: TEST_CLIENT, - }); - }, 120000); - - it("should have erc1155 module", async () => { - const modules = await getInstalledModules({ contract }); - expect(modules.length).toBe(2); - }); - - it("should upload metadata", async () => { - const transaction = BatchMetadataERC1155.uploadMetadata({ - contract, - metadatas: Array.from( - { length: 10 }, - (_, index) => - `ipfs://QmP4JFzBhTGvb27GnJ9eL9vZGYpNBGjHnPudWndruiNERm/${index}`, - ), - }); - - await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_A, - transaction, + ).rejects.toThrowError(/ClaimableOutOfTimeWindow/); }); - }); - it("should not claim without claim conditions", async () => { - // should throw - await expect( - sendAndConfirmTransaction({ + it("should claim tokens with claim conditions", async () => { + await sendAndConfirmTransaction({ account: TEST_ACCOUNT_A, - transaction: ClaimableERC1155.mint({ + transaction: ClaimableERC1155.setClaimCondition({ contract, - quantity: 1, - to: TEST_ACCOUNT_A.address, - tokenId: 123123123213n, + maxClaimableSupply: "1", + pricePerToken: "0.1", + tokenId: 0n, }), - }), - ).rejects.toThrowError(/ClaimableOutOfTimeWindow/); - }); + }); + + // should throw if claiming more than supply + await expect( + sendAndConfirmTransaction({ + account: TEST_ACCOUNT_A, + transaction: ClaimableERC1155.mint({ + contract, + quantity: 1000, + to: TEST_ACCOUNT_A.address, + tokenId: 0n, + }), + }), + ).rejects.toThrowError(/ClaimableOutOfSupply/); - it("should claim tokens with claim conditions", async () => { - await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_A, - transaction: ClaimableERC1155.setClaimCondition({ + let balance = await balanceOf({ contract, - maxClaimableSupply: "1", - pricePerToken: "0.1", + owner: TEST_ACCOUNT_A.address, tokenId: 0n, - }), - }); + }); - // should throw if claiming more than supply - await expect( - sendAndConfirmTransaction({ + expect(balance).toBe(0n); + + await sendAndConfirmTransaction({ account: TEST_ACCOUNT_A, transaction: ClaimableERC1155.mint({ contract, - quantity: 1000, + quantity: 1, to: TEST_ACCOUNT_A.address, tokenId: 0n, }), - }), - ).rejects.toThrowError(/ClaimableOutOfSupply/); + }); - let balance = await balanceOf({ - contract, - owner: TEST_ACCOUNT_A.address, - tokenId: 0n, - }); - - expect(balance).toBe(0n); - - await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_A, - transaction: ClaimableERC1155.mint({ + balance = await balanceOf({ contract, - quantity: 1, - to: TEST_ACCOUNT_A.address, + owner: TEST_ACCOUNT_A.address, tokenId: 0n, - }), - }); + }); + expect(balance).toBe(1n); - balance = await balanceOf({ - contract, - owner: TEST_ACCOUNT_A.address, - tokenId: 0n, - }); - expect(balance).toBe(1n); - - const all = await getNFTs({ - contract, - }); - expect(all.length).toBe(10); - - const owned = await getOwnedNFTs({ - address: TEST_ACCOUNT_A.address, - contract, - }); - expect(owned.length).toBe(1); - expect(owned?.[0]?.metadata.name).toBe("Test 0"); - expect(owned?.[0]?.quantityOwned).toBe(1n); - }); + const all = await getNFTs({ + contract, + }); + expect(all.length).toBe(10); - it("should claim tokens with allowlist", async () => { - await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_A, - transaction: ClaimableERC1155.setClaimCondition({ - allowList: [TEST_ACCOUNT_A.address, TEST_ACCOUNT_B.address], + const owned = await getOwnedNFTs({ + address: TEST_ACCOUNT_A.address, contract, - maxClaimableSupply: "2", - pricePerToken: "0.1", - tokenId: 0n, - }), + }); + expect(owned.length).toBe(1); + expect(owned?.[0]?.metadata.name).toBe("Test 0"); + expect(owned?.[0]?.quantityOwned).toBe(1n); }); - // should throw if not in allowlist - await expect( - sendAndConfirmTransaction({ - account: TEST_ACCOUNT_C, - transaction: ClaimableERC1155.mint({ + it("should claim tokens with allowlist", async () => { + await sendAndConfirmTransaction({ + account: TEST_ACCOUNT_A, + transaction: ClaimableERC1155.setClaimCondition({ + allowList: [TEST_ACCOUNT_A.address, TEST_ACCOUNT_B.address], contract, - quantity: 1, - to: TEST_ACCOUNT_C.address, + maxClaimableSupply: "2", + pricePerToken: "0.1", tokenId: 0n, }), - }), - ).rejects.toThrowError(/ClaimableNotInAllowlist/); + }); + + // should throw if not in allowlist + await expect( + sendAndConfirmTransaction({ + account: TEST_ACCOUNT_C, + transaction: ClaimableERC1155.mint({ + contract, + quantity: 1, + to: TEST_ACCOUNT_C.address, + tokenId: 0n, + }), + }), + ).rejects.toThrowError(/ClaimableNotInAllowlist/); + + // should throw if in allowlist but over supply + await expect( + sendAndConfirmTransaction({ + account: TEST_ACCOUNT_C, + transaction: ClaimableERC1155.mint({ + contract, + quantity: 3, + to: TEST_ACCOUNT_C.address, + tokenId: 0n, + }), + }), + ).rejects.toThrowError(/ClaimableOutOfSupply/); - // should throw if in allowlist but over supply - await expect( - sendAndConfirmTransaction({ + // can claim to address in allowlist (regardless of sender) + await sendAndConfirmTransaction({ account: TEST_ACCOUNT_C, transaction: ClaimableERC1155.mint({ contract, - quantity: 3, - to: TEST_ACCOUNT_C.address, + quantity: 2, + to: TEST_ACCOUNT_B.address, tokenId: 0n, }), - }), - ).rejects.toThrowError(/ClaimableOutOfSupply/); + }); - // can claim to address in allowlist (regardless of sender) - await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_C, - transaction: ClaimableERC1155.mint({ + const balance = await balanceOf({ contract, - quantity: 2, - to: TEST_ACCOUNT_B.address, + owner: TEST_ACCOUNT_B.address, tokenId: 0n, - }), + }); + expect(balance).toBe(2n); }); - const balance = await balanceOf({ - contract, - owner: TEST_ACCOUNT_B.address, - tokenId: 0n, - }); - expect(balance).toBe(2n); - }); + it("should claim tokens with max per wallet", async () => { + await sendAndConfirmTransaction({ + account: TEST_ACCOUNT_A, + transaction: ClaimableERC1155.setClaimCondition({ + contract, + maxClaimablePerWallet: 1, + maxClaimableSupply: 10, + tokenId: 0n, + }), + }); - it("should claim tokens with max per wallet", async () => { - await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_A, - transaction: ClaimableERC1155.setClaimCondition({ + let balance = await balanceOf({ contract, - maxClaimablePerWallet: 1, - maxClaimableSupply: 10, + owner: TEST_ACCOUNT_C.address, tokenId: 0n, - }), - }); - - let balance = await balanceOf({ - contract, - owner: TEST_ACCOUNT_C.address, - tokenId: 0n, - }); - expect(balance).toBe(0n); + }); + expect(balance).toBe(0n); + + // should throw if max per wallet is reached + await expect( + sendAndConfirmTransaction({ + account: TEST_ACCOUNT_C, + transaction: ClaimableERC1155.mint({ + contract, + quantity: 4, + to: TEST_ACCOUNT_C.address, + tokenId: 0n, + }), + }), + ).rejects.toThrowError(/ClaimableMaxMintPerWalletExceeded/); - // should throw if max per wallet is reached - await expect( - sendAndConfirmTransaction({ + await sendAndConfirmTransaction({ account: TEST_ACCOUNT_C, transaction: ClaimableERC1155.mint({ contract, - quantity: 4, + quantity: 1, to: TEST_ACCOUNT_C.address, tokenId: 0n, }), - }), - ).rejects.toThrowError(/ClaimableMaxMintPerWalletExceeded/); + }); - await sendAndConfirmTransaction({ - account: TEST_ACCOUNT_C, - transaction: ClaimableERC1155.mint({ + balance = await balanceOf({ contract, - quantity: 1, - to: TEST_ACCOUNT_C.address, + owner: TEST_ACCOUNT_C.address, tokenId: 0n, - }), - }); - - balance = await balanceOf({ - contract, - owner: TEST_ACCOUNT_C.address, - tokenId: 0n, + }); + expect(balance).toBe(1n); }); - expect(balance).toBe(1n); }); -}); diff --git a/packages/thirdweb/src/extensions/modules/ClaimableERC20/claimableERC20.test.ts b/packages/thirdweb/src/extensions/modules/ClaimableERC20/claimableERC20.test.ts index 0c3fcc40d77..7686c69352a 100644 --- a/packages/thirdweb/src/extensions/modules/ClaimableERC20/claimableERC20.test.ts +++ b/packages/thirdweb/src/extensions/modules/ClaimableERC20/claimableERC20.test.ts @@ -17,7 +17,7 @@ import { deployModularContract } from "../../prebuilts/deploy-modular.js"; import { getInstalledModules } from "../__generated__/IModularCore/read/getInstalledModules.js"; import * as ClaimableERC20 from "./index.js"; -describe.runIf(process.env.TW_SECRET_KEY)("ModularDropERC20", () => { +describe.runIf(process.env.TW_SECRET_KEY).skip("ModularDropERC20", () => { let contract: ThirdwebContract; beforeAll(async () => { const address = await deployModularContract({ diff --git a/packages/thirdweb/src/extensions/modules/ClaimableERC721/claimableERC721.test.ts b/packages/thirdweb/src/extensions/modules/ClaimableERC721/claimableERC721.test.ts index 716b350c8ea..33853e0667b 100644 --- a/packages/thirdweb/src/extensions/modules/ClaimableERC721/claimableERC721.test.ts +++ b/packages/thirdweb/src/extensions/modules/ClaimableERC721/claimableERC721.test.ts @@ -18,7 +18,7 @@ import { getInstalledModules } from "../__generated__/IModularCore/read/getInsta import * as BatchMetadataERC721 from "../BatchMetadataERC721/index.js"; import * as ClaimableERC721 from "./index.js"; -describe.runIf(process.env.TW_SECRET_KEY)("ModularClaimableERC721", () => { +describe.runIf(process.env.TW_SECRET_KEY).skip("ModularClaimableERC721", () => { let contract: ThirdwebContract; beforeAll(async () => { const address = await deployModularContract({ diff --git a/packages/thirdweb/src/extensions/prebuilts/process-ref-deployments.test.ts b/packages/thirdweb/src/extensions/prebuilts/process-ref-deployments.test.ts index 89ee2ea11e6..886d60c5205 100644 --- a/packages/thirdweb/src/extensions/prebuilts/process-ref-deployments.test.ts +++ b/packages/thirdweb/src/extensions/prebuilts/process-ref-deployments.test.ts @@ -8,7 +8,7 @@ import { readContract } from "../../transaction/read-contract.js"; import { getInstalledModules } from "../modules/__generated__/IModularCore/read/getInstalledModules.js"; import { deployPublishedContract } from "./deploy-published.js"; -describe.runIf(process.env.TW_SECRET_KEY)( +describe.runIf(process.env.TW_SECRET_KEY).skip( "deployref", { timeout: 120000,