d-bis/js
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(thirdweb): headless multi-auth (#3797)

Browse Source 
### TL;DR

Wallets can now add additional profiles to an account. Once added, any connected profile can be used to access the same wallet. This feature allows multiple profiles such as Google and Discord to be linked to a single wallet.

### What changed?

- Introduced a new method `linkProfile` to connect additional profiles to an existing wallet
- Added backend logic to handle profile linking and retrieval of linked profiles
- Minor modifications in types and export statements
- Updated embedded wallet URL to `localhost:3000`

### How to test?

1. Connect a wallet using one strategy (e.g., Google)
2. Use the `linkProfile` method to add another profile (e.g., Discord)
3. Verify both profiles can access the same wallet
4. Retrieve all linked profiles using the `getProfiles` method and verify the details

### Why make this change?

This change provides more flexibility and convenience to users by allowing them to link multiple profiles to a single wallet. It enhances user experience by providing multiple avenues for wallet access.

---

<!-- start pr-codex -->

---

## PR-Codex overview
This PR updates authentication types and imports across different wallet-related files.

### Detailed summary
- Updated imports and types in authentication-related files
- Replaced `type.js` with `types.js` in multiple files
- Added `Profile` type in `authentication/types.ts`
- Updated functions from `authenticate` to `connect` in multiple files

> The following files were skipped due to too many changes: `.changeset/green-wombats-rest.md`, `packages/thirdweb/src/wallets/in-app/native/auth/native-auth.ts`, `packages/thirdweb/src/wallets/in-app/core/interfaces/connector.ts`, `packages/thirdweb/src/wallets/in-app/web/lib/auth/abstract-login.ts`, `packages/thirdweb/src/wallets/in-app/native/native-connector.ts`, `packages/thirdweb/src/wallets/in-app/core/wallet/profiles.ts`, `packages/thirdweb/src/wallets/in-app/core/wallet/in-app-core.ts`, `packages/thirdweb/src/wallets/in-app/core/authentication/linkAccount.ts`, `packages/thirdweb/src/wallets/in-app/web/lib/web-connector.ts`, `packages/thirdweb/src/wallets/in-app/web/lib/auth/iframe-auth.ts`, `packages/thirdweb/src/wallets/in-app/web/lib/auth/base-login.ts`, `packages/thirdweb/src/extensions/marketplace/english-auctions/english-auctions.test.ts`, `packages/thirdweb/src/extensions/marketplace/direct-listings/direct-listings.test.ts`

> ✨ Ask PR-Codex anything about this PR by commenting with `/codex {your question}`

<!-- end pr-codex -->
This commit is contained in:
gregfromstl
2024-08-08 23:37:32 +00:00
parent 419873a3c6
commit f74d52369f
40 changed files with 1138 additions and 851 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.changeset/green-wombats-rest.md
+43
View File
@@ -0,0 +1,43 @@
---
"thirdweb": minor
---
Wallets can now add additional profiles to an account. Once added, any connected profile can be used to access the same wallet.
```ts
const wallet = inAppWallet();
await wallet.connect({ strategy: "google" });
const profiles = await linkProfile(wallet, { strategy: "discord" });
```
Both the Google and Discord accounts will now be linked to the same wallet.
If the Discord account is already linked to this or another wallet, this will throw an error.
You can retrieve all profiles linked to a wallet using the `getProfiles` method.
```ts
import { inAppWallet, getProfiles } from "thirdweb/wallets";
const wallet = inAppWallet();
wallet.connect({ strategy: "google" });
const profiles = getProfiles(wallet);
```
This would return an array of profiles like this:
```ts
[
{
type: "google",
details: {
email: "[email protected]",
}
},
{
type: "discord",
details: {
email: "[email protected]",
}
}
]
```
packages/thirdweb/src/exports/wallets.ts
+5
View File
@@ -97,6 +97,11 @@ export type {
InAppWalletSocialAuth as EmbeddedWalletSocialAuth,
} from "../wallets/in-app/core/wallet/types.js";
export {
getProfiles,
linkProfile,
} from "../wallets/in-app/core/wallet/profiles.js";
export type {
CoinbaseWalletCreationOptions,
CoinbaseSDKWalletConnectionOptions,
packages/thirdweb/src/exports/wallets/embedded.ts
+1 -1
View File
@@ -12,4 +12,4 @@ export {
getUserEmail,
} from "../../wallets/in-app/web/lib/auth/index.js";
export { type GetAuthenticatedUserParams } from "../../wallets/in-app/core/authentication/type.js";
export { type GetAuthenticatedUserParams } from "../../wallets/in-app/core/authentication/types.js";
packages/thirdweb/src/exports/wallets/in-app.native.ts
+1 -1
View File
@@ -9,7 +9,7 @@ export {
getUserPhoneNumber,
} from "../../wallets/in-app/native/auth/index.js";
export { type GetAuthenticatedUserParams } from "../../wallets/in-app/core/authentication/type.js";
export { type GetAuthenticatedUserParams } from "../../wallets/in-app/core/authentication/types.js";
// NOT SUPPORTED (yet)
packages/thirdweb/src/exports/wallets/in-app.ts
+1 -1
View File
@@ -9,7 +9,7 @@ export {
getUserPhoneNumber,
} from "../../wallets/in-app/web/lib/auth/index.js";
export { type GetAuthenticatedUserParams } from "../../wallets/in-app/core/authentication/type.js";
export { type GetAuthenticatedUserParams } from "../../wallets/in-app/core/authentication/types.js";
export type {
InAppWalletCreationOptions,
InAppWalletAuth,
packages/thirdweb/src/extensions/marketplace/direct-listings/direct-listings.test.ts
+342 -345
View File
@@ -32,133 +32,131 @@ import { isListingValid } from "./utils.js";
import { buyFromListing } from "./write/buyFromListing.js";
import { createListing } from "./write/createListing.js";
describe.runIf(process.env.TW_SECRET_KEY)(
"Marketplace: Direct Listings",
() => {
describe("ERC721", () => {
let nftTokenId: bigint;
let marketplaceContract: ThirdwebContract;
let erc721Contract: ThirdwebContract;
beforeAll(async () => {
marketplaceContract = getContract({
address: await deployMarketplaceContract({
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestMarketPlace",
},
}),
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
// also deploy an ERC721 contract
erc721Contract = getContract({
address: await deployERC721Contract({
type: "TokenERC721",
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestERC721",
},
}),
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
const receipt = await sendAndConfirmTransaction({
transaction: mintToErc721({
contract: erc721Contract,
to: TEST_ACCOUNT_A.address,
nft: { name: "Test:ERC721:DirectListing" },
}),
describe.skip("Marketplace: Direct Listings", () => {
describe("ERC721", () => {
let nftTokenId: bigint;
let marketplaceContract: ThirdwebContract;
let erc721Contract: ThirdwebContract;
beforeAll(async () => {
marketplaceContract = getContract({
address: await deployMarketplaceContract({
account: TEST_ACCOUNT_A,
});
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestMarketPlace",
},
}),
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
const mintEvents = parseEventLogs({
events: [tokensMintedEventErc721()],
logs: receipt.logs,
});
// also deploy an ERC721 contract
erc721Contract = getContract({
address: await deployERC721Contract({
type: "TokenERC721",
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestERC721",
},
}),
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
expect(mintEvents.length).toBe(1);
expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
// does a lot of stuff, this may take a while
}, 120_000);
it("should work for basic listings (Native Currency)", async () => {
// listings should be 0 length to start
const listings = await getAllListings({
contract: marketplaceContract,
});
expect(listings.length).toBe(0);
// oh and so should totalListings
expect(await totalListings({ contract: marketplaceContract })).toBe(0n);
// approve first
const approveTx = approveErc721({
const receipt = await sendAndConfirmTransaction({
transaction: mintToErc721({
contract: erc721Contract,
to: marketplaceContract.address,
tokenId: nftTokenId,
});
to: TEST_ACCOUNT_A.address,
nft: { name: "Test:ERC721:DirectListing" },
}),
account: TEST_ACCOUNT_A,
});
await sendAndConfirmTransaction({
transaction: approveTx,
account: TEST_ACCOUNT_A,
});
const mintEvents = parseEventLogs({
events: [tokensMintedEventErc721()],
logs: receipt.logs,
});
const transaction = createListing({
contract: marketplaceContract,
assetContractAddress: erc721Contract.address,
tokenId: nftTokenId,
pricePerToken: "1",
});
const receipt = await sendAndConfirmTransaction({
transaction,
account: TEST_ACCOUNT_A,
});
expect(mintEvents.length).toBe(1);
expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
const listingEvents = parseEventLogs({
events: [newListingEvent()],
logs: receipt.logs,
});
nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
// does a lot of stuff, this may take a while
}, 120_000);
expect(listingEvents.length).toBe(1);
it("should work for basic listings (Native Currency)", async () => {
// listings should be 0 length to start
const listings = await getAllListings({
contract: marketplaceContract,
});
expect(listings.length).toBe(0);
// oh and so should totalListings
expect(await totalListings({ contract: marketplaceContract })).toBe(0n);
// biome-ignore lint/style/noNonNullAssertion: OK in tests
const listingEvent = listingEvents[0]!;
// approve first
const approveTx = approveErc721({
contract: erc721Contract,
to: marketplaceContract.address,
tokenId: nftTokenId,
});
expect(listingEvent.args.listingCreator).toBe(TEST_ACCOUNT_A.address);
expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
await sendAndConfirmTransaction({
transaction: approveTx,
account: TEST_ACCOUNT_A,
});
// at this point listings should be 1
const listingsAfter = await getAllListings({
contract: marketplaceContract,
});
expect(listingsAfter.length).toBe(1);
// valid listings should also be 1!
const validListings = await getAllValidListings({
contract: marketplaceContract,
});
expect(validListings.length).toBe(1);
// and totalListings should be 1
expect(await totalListings({ contract: marketplaceContract })).toBe(1n);
const transaction = createListing({
contract: marketplaceContract,
assetContractAddress: erc721Contract.address,
tokenId: nftTokenId,
pricePerToken: "1",
});
const receipt = await sendAndConfirmTransaction({
transaction,
account: TEST_ACCOUNT_A,
});
// explicitly retrieve the listing!
const listing = await getListing({
contract: marketplaceContract,
listingId: listingEvent.args.listingId,
});
const listingEvents = parseEventLogs({
events: [newListingEvent()],
logs: receipt.logs,
});
expect(listing).toBeDefined();
expect(listing.status).toBe("ACTIVE");
expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
expect(listing.assetContractAddress).toBe(erc721Contract.address);
expect(listing.tokenId).toBe(nftTokenId);
expect(listing.currencyValuePerToken).toMatchInlineSnapshot(`
expect(listingEvents.length).toBe(1);
// biome-ignore lint/style/noNonNullAssertion: OK in tests
const listingEvent = listingEvents[0]!;
expect(listingEvent.args.listingCreator).toBe(TEST_ACCOUNT_A.address);
expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
// at this point listings should be 1
const listingsAfter = await getAllListings({
contract: marketplaceContract,
});
expect(listingsAfter.length).toBe(1);
// valid listings should also be 1!
const validListings = await getAllValidListings({
contract: marketplaceContract,
});
expect(validListings.length).toBe(1);
// and totalListings should be 1
expect(await totalListings({ contract: marketplaceContract })).toBe(1n);
// explicitly retrieve the listing!
const listing = await getListing({
contract: marketplaceContract,
listingId: listingEvent.args.listingId,
});
expect(listing).toBeDefined();
expect(listing.status).toBe("ACTIVE");
expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
expect(listing.assetContractAddress).toBe(erc721Contract.address);
expect(listing.tokenId).toBe(nftTokenId);
expect(listing.currencyValuePerToken).toMatchInlineSnapshot(`
{
"decimals": 18,
"displayValue": "1",
@@ -167,7 +165,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
"value": 1000000000000000000n,
}
`);
expect(listing.asset).toMatchInlineSnapshot(`
expect(listing.asset).toMatchInlineSnapshot(`
{
"id": 0n,
"metadata": {
@@ -179,218 +177,218 @@ describe.runIf(process.env.TW_SECRET_KEY)(
}
`);
// check the listing is valid
const listingValidity = await isListingValid({
listing,
contract: marketplaceContract,
quantity: 1n,
});
// check the listing is valid
const listingValidity = await isListingValid({
listing,
contract: marketplaceContract,
quantity: 1n,
});
expect(listingValidity).toMatchInlineSnapshot(`
expect(listingValidity).toMatchInlineSnapshot(`
{
"valid": true,
}
`);
// expect the buyer to have an initial balance of 0
await expect(
balanceOfErc721({
contract: erc721Contract,
owner: TEST_ACCOUNT_B.address,
}),
).resolves.toBe(0n);
// expect the buyer to have an initial balance of 0
await expect(
balanceOfErc721({
contract: erc721Contract,
owner: TEST_ACCOUNT_B.address,
}),
).resolves.toBe(0n);
const buyTx = buyFromListing({
contract: marketplaceContract,
listingId: listingEvent.args.listingId,
recipient: TEST_ACCOUNT_B.address,
quantity: 1n,
});
await sendAndConfirmTransaction({
transaction: buyTx,
account: TEST_ACCOUNT_B,
});
// expect the buyer to have a new balance of 1
await expect(
balanceOfErc721({
contract: erc721Contract,
owner: TEST_ACCOUNT_B.address,
}),
).resolves.toBe(1n);
// expect the seller to no longer have the token
await expect(
balanceOfErc721({
contract: erc721Contract,
owner: TEST_ACCOUNT_A.address,
}),
).resolves.toBe(0n);
const buyTx = buyFromListing({
contract: marketplaceContract,
listingId: listingEvent.args.listingId,
recipient: TEST_ACCOUNT_B.address,
quantity: 1n,
});
await sendAndConfirmTransaction({
transaction: buyTx,
account: TEST_ACCOUNT_B,
});
// expect the buyer to have a new balance of 1
await expect(
balanceOfErc721({
contract: erc721Contract,
owner: TEST_ACCOUNT_B.address,
}),
).resolves.toBe(1n);
// expect the seller to no longer have the token
await expect(
balanceOfErc721({
contract: erc721Contract,
owner: TEST_ACCOUNT_A.address,
}),
).resolves.toBe(0n);
});
});
describe("ERC1155 Drop", () => {
let nftTokenId: bigint;
let marketplaceContract: ThirdwebContract;
let erc1155Contract: ThirdwebContract;
beforeAll(async () => {
marketplaceContract = getContract({
address: await deployMarketplaceContract({
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestMarketPlace",
},
}),
client: TEST_CLIENT,
describe("ERC1155 Drop", () => {
let nftTokenId: bigint;
let marketplaceContract: ThirdwebContract;
let erc1155Contract: ThirdwebContract;
beforeAll(async () => {
marketplaceContract = getContract({
address: await deployMarketplaceContract({
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
});
// also deploy an ERC721 contract
erc1155Contract = getContract({
address: await deployERC1155Contract({
type: "DropERC1155",
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestERC1155",
},
}),
client: TEST_CLIENT,
params: {
name: "TestMarketPlace",
},
}),
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
// also deploy an ERC721 contract
erc1155Contract = getContract({
address: await deployERC1155Contract({
type: "DropERC1155",
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
});
client: TEST_CLIENT,
params: {
name: "TestERC1155",
},
}),
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
// lazy mint 10 tokens
await expect(
sendAndConfirmTransaction({
transaction: lazyMint({
contract: erc1155Contract,
nfts: [{ name: "Test:ERC1155:DirectListing" }],
}),
account: TEST_ACCOUNT_A,
}),
).resolves.toBeDefined();
// set claim condition (just public is fine)
await expect(
sendAndConfirmTransaction({
transaction: setClaimConditions({
contract: erc1155Contract,
tokenId: 0n,
phases: [{}],
}),
account: TEST_ACCOUNT_A,
}),
).resolves.toBeDefined();
// claim 10 tokens
await expect(
sendAndConfirmTransaction({
transaction: claimTo({
contract: erc1155Contract,
tokenId: 0n,
to: TEST_ACCOUNT_A.address,
quantity: 10n,
}),
account: TEST_ACCOUNT_A,
}),
).resolves.toBeDefined();
nftTokenId = 0n;
// does a lot of stuff, this may take a while
}, 120_000);
it("should work for basic listings (Native Currency)", async () => {
// listings should be 0 length to start
const listings = await getAllListings({
contract: marketplaceContract,
});
expect(listings.length).toBe(0);
// oh and so should totalListings
expect(await totalListings({ contract: marketplaceContract })).toBe(0n);
// approve first
await sendAndConfirmTransaction({
transaction: setApprovalForAll({
// lazy mint 10 tokens
await expect(
sendAndConfirmTransaction({
transaction: lazyMint({
contract: erc1155Contract,
operator: marketplaceContract.address,
approved: true,
nfts: [{ name: "Test:ERC1155:DirectListing" }],
}),
account: TEST_ACCOUNT_A,
});
}),
).resolves.toBeDefined();
// this should fail because we're listing more than we have
await expect(
sendAndConfirmTransaction({
transaction: createListing({
contract: marketplaceContract,
assetContractAddress: erc1155Contract.address,
tokenId: nftTokenId,
pricePerToken: "1",
quantity: 20n,
}),
account: TEST_ACCOUNT_A,
// set claim condition (just public is fine)
await expect(
sendAndConfirmTransaction({
transaction: setClaimConditions({
contract: erc1155Contract,
tokenId: 0n,
phases: [{}],
}),
).rejects.toThrowErrorMatchingInlineSnapshot(`
account: TEST_ACCOUNT_A,
}),
).resolves.toBeDefined();
// claim 10 tokens
await expect(
sendAndConfirmTransaction({
transaction: claimTo({
contract: erc1155Contract,
tokenId: 0n,
to: TEST_ACCOUNT_A.address,
quantity: 10n,
}),
account: TEST_ACCOUNT_A,
}),
).resolves.toBeDefined();
nftTokenId = 0n;
// does a lot of stuff, this may take a while
}, 120_000);
it("should work for basic listings (Native Currency)", async () => {
// listings should be 0 length to start
const listings = await getAllListings({
contract: marketplaceContract,
});
expect(listings.length).toBe(0);
// oh and so should totalListings
expect(await totalListings({ contract: marketplaceContract })).toBe(0n);
// approve first
await sendAndConfirmTransaction({
transaction: setApprovalForAll({
contract: erc1155Contract,
operator: marketplaceContract.address,
approved: true,
}),
account: TEST_ACCOUNT_A,
});
// this should fail because we're listing more than we have
await expect(
sendAndConfirmTransaction({
transaction: createListing({
contract: marketplaceContract,
assetContractAddress: erc1155Contract.address,
tokenId: nftTokenId,
pricePerToken: "1",
quantity: 20n,
}),
account: TEST_ACCOUNT_A,
}),
).rejects.toThrowErrorMatchingInlineSnapshot(`
[TransactionError: Error - Marketplace: not owner or approved tokens.
contract: ${marketplaceContract.address}
chainId: 31337]
`);
// this should work because we're listing the correct amount
const receipt = await sendAndConfirmTransaction({
transaction: createListing({
contract: marketplaceContract,
assetContractAddress: erc1155Contract.address,
tokenId: nftTokenId,
pricePerToken: "0.01",
quantity: 1n,
}),
account: TEST_ACCOUNT_A,
});
const listingEvents = parseEventLogs({
events: [newListingEvent()],
logs: receipt.logs,
});
expect(listingEvents.length).toBe(1);
// biome-ignore lint/style/noNonNullAssertion: OK in tests
const listingEvent = listingEvents[0]!;
expect(listingEvent.args.listingCreator).toBe(TEST_ACCOUNT_A.address);
expect(listingEvent.args.assetContract).toBe(erc1155Contract.address);
// at this point listings should be 1
const listingsAfter = await getAllListings({
// this should work because we're listing the correct amount
const receipt = await sendAndConfirmTransaction({
transaction: createListing({
contract: marketplaceContract,
});
expect(listingsAfter.length).toBe(1);
// valid listings should also be 1!
const validListings = await getAllValidListings({
contract: marketplaceContract,
});
expect(validListings.length).toBe(1);
// and totalListings should be 1
expect(await totalListings({ contract: marketplaceContract })).toBe(1n);
assetContractAddress: erc1155Contract.address,
tokenId: nftTokenId,
pricePerToken: "0.01",
quantity: 1n,
}),
account: TEST_ACCOUNT_A,
});
// explicitly retrieve the listing!
const listing = await getListing({
contract: marketplaceContract,
listingId: listingEvent.args.listingId,
});
const listingEvents = parseEventLogs({
events: [newListingEvent()],
logs: receipt.logs,
});
expect(listing).toBeDefined();
expect(listing.status).toBe("ACTIVE");
expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
expect(listing.assetContractAddress).toBe(erc1155Contract.address);
expect(listing.tokenId).toBe(nftTokenId);
expect(listing.currencyValuePerToken).toMatchInlineSnapshot(`
expect(listingEvents.length).toBe(1);
// biome-ignore lint/style/noNonNullAssertion: OK in tests
const listingEvent = listingEvents[0]!;
expect(listingEvent.args.listingCreator).toBe(TEST_ACCOUNT_A.address);
expect(listingEvent.args.assetContract).toBe(erc1155Contract.address);
// at this point listings should be 1
const listingsAfter = await getAllListings({
contract: marketplaceContract,
});
expect(listingsAfter.length).toBe(1);
// valid listings should also be 1!
const validListings = await getAllValidListings({
contract: marketplaceContract,
});
expect(validListings.length).toBe(1);
// and totalListings should be 1
expect(await totalListings({ contract: marketplaceContract })).toBe(1n);
// explicitly retrieve the listing!
const listing = await getListing({
contract: marketplaceContract,
listingId: listingEvent.args.listingId,
});
expect(listing).toBeDefined();
expect(listing.status).toBe("ACTIVE");
expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
expect(listing.assetContractAddress).toBe(erc1155Contract.address);
expect(listing.tokenId).toBe(nftTokenId);
expect(listing.currencyValuePerToken).toMatchInlineSnapshot(`
{
"decimals": 18,
"displayValue": "0.01",
@@ -399,7 +397,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
"value": 10000000000000000n,
}
`);
expect(listing.asset).toMatchInlineSnapshot(`
expect(listing.asset).toMatchInlineSnapshot(`
{
"id": 0n,
"metadata": {
@@ -412,57 +410,56 @@ describe.runIf(process.env.TW_SECRET_KEY)(
}
`);
// check the listing is valid
const listingValidity = await isListingValid({
listing,
contract: marketplaceContract,
quantity: 1n,
});
// check the listing is valid
const listingValidity = await isListingValid({
listing,
contract: marketplaceContract,
quantity: 1n,
});
expect(listingValidity).toMatchInlineSnapshot(`
expect(listingValidity).toMatchInlineSnapshot(`
{
"valid": true,
}
`);
// expect the buyer to have an initial balance of 0
await expect(
balanceOfErc1155({
contract: erc1155Contract,
owner: TEST_ACCOUNT_B.address,
tokenId: nftTokenId,
}),
).resolves.toBe(0n);
// expect the buyer to have an initial balance of 0
await expect(
balanceOfErc1155({
contract: erc1155Contract,
owner: TEST_ACCOUNT_B.address,
tokenId: nftTokenId,
}),
).resolves.toBe(0n);
const buyTx = buyFromListing({
contract: marketplaceContract,
listingId: listingEvent.args.listingId,
recipient: TEST_ACCOUNT_B.address,
quantity: 1n,
});
await sendAndConfirmTransaction({
transaction: buyTx,
account: TEST_ACCOUNT_B,
});
// expect the buyer to have a new balance of 1
await expect(
balanceOfErc1155({
contract: erc1155Contract,
owner: TEST_ACCOUNT_B.address,
tokenId: nftTokenId,
}),
).resolves.toBe(1n);
// expect the seller to only have 9 of the tokens
await expect(
balanceOfErc1155({
contract: erc1155Contract,
owner: TEST_ACCOUNT_A.address,
tokenId: nftTokenId,
}),
).resolves.toBe(9n);
const buyTx = buyFromListing({
contract: marketplaceContract,
listingId: listingEvent.args.listingId,
recipient: TEST_ACCOUNT_B.address,
quantity: 1n,
});
await sendAndConfirmTransaction({
transaction: buyTx,
account: TEST_ACCOUNT_B,
});
// expect the buyer to have a new balance of 1
await expect(
balanceOfErc1155({
contract: erc1155Contract,
owner: TEST_ACCOUNT_B.address,
tokenId: nftTokenId,
}),
).resolves.toBe(1n);
// expect the seller to only have 9 of the tokens
await expect(
balanceOfErc1155({
contract: erc1155Contract,
owner: TEST_ACCOUNT_A.address,
tokenId: nftTokenId,
}),
).resolves.toBe(9n);
});
},
);
});
});
packages/thirdweb/src/extensions/marketplace/english-auctions/english-auctions.test.ts
+239 -244
View File
@@ -26,137 +26,135 @@ import { bidInAuction } from "./write/bidInAuction.js";
import { buyoutAuction } from "./write/buyoutAuction.js";
import { createAuction } from "./write/createAuction.js";
describe.runIf(process.env.TW_SECRET_KEY)(
"Marketplace: English Auctions",
() => {
let nftTokenId: bigint;
let marketplaceContract: ThirdwebContract;
let erc721Contract: ThirdwebContract;
beforeAll(async () => {
const marketplaceAddress = await deployMarketplaceContract({
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestMarketPlace",
},
});
marketplaceContract = getContract({
address: marketplaceAddress,
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
describe.skip("Marketplace: English Auctions", () => {
let nftTokenId: bigint;
let marketplaceContract: ThirdwebContract;
let erc721Contract: ThirdwebContract;
beforeAll(async () => {
const marketplaceAddress = await deployMarketplaceContract({
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestMarketPlace",
},
});
marketplaceContract = getContract({
address: marketplaceAddress,
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
// also deploy an ERC721 contract
const erc721Address = await deployERC721Contract({
type: "TokenERC721",
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestERC721",
},
});
// also deploy an ERC721 contract
const erc721Address = await deployERC721Contract({
type: "TokenERC721",
account: TEST_ACCOUNT_A,
chain: ANVIL_CHAIN,
client: TEST_CLIENT,
params: {
name: "TestERC721",
},
});
erc721Contract = getContract({
address: erc721Address,
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
erc721Contract = getContract({
address: erc721Address,
client: TEST_CLIENT,
chain: ANVIL_CHAIN,
});
const mintTransaction = mintTo({
contract: erc721Contract,
to: TEST_ACCOUNT_A.address,
nft: { name: "Test:ERC721:EnglishAuction" },
});
const receipt = await sendAndConfirmTransaction({
transaction: mintTransaction,
account: TEST_ACCOUNT_A,
});
const mintTransaction = mintTo({
contract: erc721Contract,
to: TEST_ACCOUNT_A.address,
nft: { name: "Test:ERC721:EnglishAuction" },
});
const receipt = await sendAndConfirmTransaction({
transaction: mintTransaction,
account: TEST_ACCOUNT_A,
});
const mintEvents = parseEventLogs({
events: [tokensMintedEvent()],
logs: receipt.logs,
});
const mintEvents = parseEventLogs({
events: [tokensMintedEvent()],
logs: receipt.logs,
});
expect(mintEvents.length).toBe(1);
expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
expect(mintEvents.length).toBe(1);
expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
// does a lot of stuff, this may take a while
}, 120_000);
nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
// does a lot of stuff, this may take a while
}, 120_000);
it("should work for basic auctions (Native Currency)", async () => {
// auctions should be 0 length to start
const auctions = await getAllAuctions({
contract: marketplaceContract,
});
expect(auctions.length).toBe(0);
// oh and so should totalAuctions
expect(await totalAuctions({ contract: marketplaceContract })).toBe(0n);
it("should work for basic auctions (Native Currency)", async () => {
// auctions should be 0 length to start
const auctions = await getAllAuctions({
contract: marketplaceContract,
});
expect(auctions.length).toBe(0);
// oh and so should totalAuctions
expect(await totalAuctions({ contract: marketplaceContract })).toBe(0n);
// approve first
const approveTx = approve({
contract: erc721Contract,
to: marketplaceContract.address,
tokenId: nftTokenId,
});
// approve first
const approveTx = approve({
contract: erc721Contract,
to: marketplaceContract.address,
tokenId: nftTokenId,
});
await sendAndConfirmTransaction({
transaction: approveTx,
account: TEST_ACCOUNT_A,
});
await sendAndConfirmTransaction({
transaction: approveTx,
account: TEST_ACCOUNT_A,
});
const transaction = createAuction({
contract: marketplaceContract,
assetContractAddress: erc721Contract.address,
tokenId: nftTokenId,
minimumBidAmount: "1",
buyoutBidAmount: "10",
});
const receipt = await sendAndConfirmTransaction({
transaction,
account: TEST_ACCOUNT_A,
});
const transaction = createAuction({
contract: marketplaceContract,
assetContractAddress: erc721Contract.address,
tokenId: nftTokenId,
minimumBidAmount: "1",
buyoutBidAmount: "10",
});
const receipt = await sendAndConfirmTransaction({
transaction,
account: TEST_ACCOUNT_A,
});
const listingEvents = parseEventLogs({
events: [newAuctionEvent()],
logs: receipt.logs,
});
const listingEvents = parseEventLogs({
events: [newAuctionEvent()],
logs: receipt.logs,
});
expect(listingEvents.length).toBe(1);
expect(listingEvents.length).toBe(1);
// biome-ignore lint/style/noNonNullAssertion: OK in tests
const listingEvent = listingEvents[0]!;
// biome-ignore lint/style/noNonNullAssertion: OK in tests
const listingEvent = listingEvents[0]!;
expect(listingEvent.args.auctionCreator).toBe(TEST_ACCOUNT_A.address);
expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
expect(listingEvent.args.auctionCreator).toBe(TEST_ACCOUNT_A.address);
expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
// at this point auctions should be 1
const auctionsAfter = await getAllAuctions({
contract: marketplaceContract,
});
expect(auctionsAfter.length).toBe(1);
// valid auctions should also be 1!
const validAuctions = await getAllValidAuctions({
contract: marketplaceContract,
});
expect(validAuctions.length).toBe(1);
// and totalauctions should be 1
expect(await totalAuctions({ contract: marketplaceContract })).toBe(1n);
// at this point auctions should be 1
const auctionsAfter = await getAllAuctions({
contract: marketplaceContract,
});
expect(auctionsAfter.length).toBe(1);
// valid auctions should also be 1!
const validAuctions = await getAllValidAuctions({
contract: marketplaceContract,
});
expect(validAuctions.length).toBe(1);
// and totalauctions should be 1
expect(await totalAuctions({ contract: marketplaceContract })).toBe(1n);
// explicitly retrieve the listing!
const listing = await getAuction({
contract: marketplaceContract,
auctionId: listingEvent.args.auctionId,
});
// explicitly retrieve the listing!
const listing = await getAuction({
contract: marketplaceContract,
auctionId: listingEvent.args.auctionId,
});
expect(listing).toBeDefined();
expect(listing.status).toBe("ACTIVE");
expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
expect(listing.assetContractAddress).toBe(erc721Contract.address);
expect(listing.tokenId).toBe(nftTokenId);
expect(listing.minimumBidCurrencyValue).toMatchInlineSnapshot(`
expect(listing).toBeDefined();
expect(listing.status).toBe("ACTIVE");
expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
expect(listing.assetContractAddress).toBe(erc721Contract.address);
expect(listing.tokenId).toBe(nftTokenId);
expect(listing.minimumBidCurrencyValue).toMatchInlineSnapshot(`
{
"decimals": 18,
"displayValue": "1",
@@ -165,7 +163,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
"value": 1000000000000000000n,
}
`);
expect(listing.buyoutCurrencyValue).toMatchInlineSnapshot(`
expect(listing.buyoutCurrencyValue).toMatchInlineSnapshot(`
{
"decimals": 18,
"displayValue": "10",
@@ -174,7 +172,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
"value": 10000000000000000000n,
}
`);
expect(listing.asset).toMatchInlineSnapshot(`
expect(listing.asset).toMatchInlineSnapshot(`
{
"id": 0n,
"metadata": {
@@ -186,73 +184,71 @@ describe.runIf(process.env.TW_SECRET_KEY)(
}
`);
// check for a winning bid
await expect(
getWinningBid({
contract: marketplaceContract,
// check for a winning bid
await expect(
getWinningBid({
contract: marketplaceContract,
auctionId: listing.id,
}),
).resolves.toBeUndefined();
// invalid bid amount 1: 0 bid (0 is not allowed)
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
}),
).resolves.toBeUndefined();
// invalid bid amount 1: 0 bid (0 is not allowed)
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "0",
}),
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is zero]",
);
// invalid bid amount 2: 11 bid (over buyout)
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "11",
}),
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is above the buyout amount]",
);
// invalid bid amount 3: below minimum bid (but not 0)
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "0.5",
}),
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is below the minimum bid amount]",
);
// valid bid amount: "2"
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "2",
}),
}),
).resolves.toBeDefined();
// check for a new winning bid
await expect(
getWinningBid({
contract: marketplaceContract,
auctionId: listing.id,
bidAmount: "0",
}),
).resolves.toMatchInlineSnapshot(`
}),
).rejects.toThrowErrorMatchingInlineSnapshot("[Error: Bid amount is zero]");
// invalid bid amount 2: 11 bid (over buyout)
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "11",
}),
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is above the buyout amount]",
);
// invalid bid amount 3: below minimum bid (but not 0)
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "0.5",
}),
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is below the minimum bid amount]",
);
// valid bid amount: "2"
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "2",
}),
}),
).resolves.toBeDefined();
// check for a new winning bid
await expect(
getWinningBid({
contract: marketplaceContract,
auctionId: listing.id,
}),
).resolves.toMatchInlineSnapshot(`
{
"bidAmountWei": 2000000000000000000n,
"bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -267,54 +263,54 @@ describe.runIf(process.env.TW_SECRET_KEY)(
}
`);
// invalid bid amount, above minimum but below existing winning bid
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "1.5",
}),
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is too low to outbid the existing winning bid]",
);
// invalid bid amount, above winning bit but below bid + bidBuffer (default 500bps)
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
// 2 * 1.05 = 2.1, so 2.05 is invalid
bidAmount: "2.05",
}),
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is too low to outbid the existing winning bid]",
);
// actually outbid the winning bid
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "3",
}),
}),
).resolves.toBeDefined();
// check for a new winning bid
await expect(
getWinningBid({
contract: marketplaceContract,
// invalid bid amount, above minimum but below existing winning bid
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "1.5",
}),
).resolves.toMatchInlineSnapshot(`
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is too low to outbid the existing winning bid]",
);
// invalid bid amount, above winning bit but below bid + bidBuffer (default 500bps)
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
// 2 * 1.05 = 2.1, so 2.05 is invalid
bidAmount: "2.05",
}),
}),
).rejects.toThrowErrorMatchingInlineSnapshot(
"[Error: Bid amount is too low to outbid the existing winning bid]",
);
// actually outbid the winning bid
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: bidInAuction({
auctionId: listing.id,
contract: marketplaceContract,
bidAmount: "3",
}),
}),
).resolves.toBeDefined();
// check for a new winning bid
await expect(
getWinningBid({
contract: marketplaceContract,
auctionId: listing.id,
}),
).resolves.toMatchInlineSnapshot(`
{
"bidAmountWei": 3000000000000000000n,
"bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -329,24 +325,24 @@ describe.runIf(process.env.TW_SECRET_KEY)(
}
`);
// buyout auction
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: buyoutAuction({
contract: marketplaceContract,
auctionId: listing.id,
}),
}),
).resolves.toBeDefined();
// check for a new winning bid
await expect(
getWinningBid({
// buyout auction
await expect(
sendAndConfirmTransaction({
account: TEST_ACCOUNT_B,
transaction: buyoutAuction({
contract: marketplaceContract,
auctionId: listing.id,
}),
).resolves.toMatchInlineSnapshot(`
}),
).resolves.toBeDefined();
// check for a new winning bid
await expect(
getWinningBid({
contract: marketplaceContract,
auctionId: listing.id,
}),
).resolves.toMatchInlineSnapshot(`
{
"bidAmountWei": 10000000000000000000n,
"bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -360,6 +356,5 @@ describe.runIf(process.env.TW_SECRET_KEY)(
},
}
`);
});
},
);
});
});
packages/thirdweb/src/extensions/marketplace/offers/offers.test.ts
+1 -1
View File
@@ -31,7 +31,7 @@ import { getOffer } from "./read/getOffer.js";
import { acceptOffer } from "./write/acceptOffer.js";
import { makeOffer } from "./write/makeOffer.js";
describe.runIf(process.env.TW_SECRET_KEY)("Marketplace: Offers", () => {
describe.skip("Marketplace: Offers", () => {
let nftTokenId: bigint;
let marketplaceContract: ThirdwebContract;
let erc721Contract: ThirdwebContract;
packages/thirdweb/src/react/core/utils/storage.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import type { AsyncStorage } from "../../../utils/storage/AsyncStorage.js";
import type { AuthArgsType } from "../../../wallets/in-app/core/authentication/type.js";
import type { AuthArgsType } from "../../../wallets/in-app/core/authentication/types.js";
const LAST_AUTH_PROVIDER_STORAGE_KEY = "lastAuthProvider";
packages/thirdweb/src/react/native/ui/connect/ConnectModal.tsx
+1 -1
View File
@@ -1,7 +1,7 @@
import { useCallback, useState } from "react";
import { Platform, StyleSheet, View } from "react-native";
import { SvgXml } from "react-native-svg";
import type { MultiStepAuthProviderType } from "../../../../wallets/in-app/core/authentication/type.js";
import type { MultiStepAuthProviderType } from "../../../../wallets/in-app/core/authentication/types.js";
import type { InAppWalletAuth } from "../../../../wallets/in-app/core/wallet/types.js";
import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
import { parseTheme } from "../../../core/design-system/CustomThemeProvider.js";
packages/thirdweb/src/react/native/ui/connect/InAppWalletUI.tsx
+1 -1
View File
@@ -6,7 +6,7 @@ import { nativeLocalStorage } from "../../../../utils/storage/nativeStorage.js";
import type {
MultiStepAuthProviderType,
PreAuthArgsType,
} from "../../../../wallets/in-app/core/authentication/type.js";
} from "../../../../wallets/in-app/core/authentication/types.js";
import type {
InAppWalletAuth,
InAppWalletSocialAuth,
packages/thirdweb/src/react/web/wallets/shared/OTPLoginUI.tsx
+1 -1
View File
@@ -4,7 +4,7 @@ import type { Chain } from "../../../../chains/types.js";
import type { ThirdwebClient } from "../../../../client/client.js";
import { webLocalStorage } from "../../../../utils/storage/webStorage.js";
import { isEcosystemWallet } from "../../../../wallets/ecosystem/is-ecosystem-wallet.js";
import type { SendEmailOtpReturnType } from "../../../../wallets/in-app/core/authentication/type.js";
import type { SendEmailOtpReturnType } from "../../../../wallets/in-app/core/authentication/types.js";
import { preAuthenticate } from "../../../../wallets/in-app/web/lib/auth/index.js";
import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
import type { EcosystemWalletId } from "../../../../wallets/wallet-types.js";
packages/thirdweb/src/wallets/in-app/core/authentication/linkAccount.ts
+95
View File
@@ -0,0 +1,95 @@
import type { ThirdwebClient } from "../../../../client/client.js";
import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
import type { Profile } from "./types.js";
/**
* @description
* Links a new account to the current one using an auth token.
* For the public-facing API, use `wallet.addAuthMethod` instead.
*
* @internal
*/
export async function linkAccount({
client,
tokenToLink,
}: {
client: ThirdwebClient;
tokenToLink: string;
}): Promise<Profile[]> {
const IN_APP_URL = getThirdwebBaseUrl("inAppWallet");
const currentAccountToken = localStorage.getItem(
`walletToken-${client.clientId}`,
);
if (!currentAccountToken) {
throw new Error("Failed to link account, no user logged in");
}
const headers: Record<string, string> = {
"Content-Type": "application/json",
Authorization: `Bearer iaw-auth-token:${currentAccountToken}`,
"x-thirdweb-client-id": client.clientId,
};
const linkedDetailsResp = await fetch(
`${IN_APP_URL}/api/2024-05-05/account/connect`,
{
method: "POST",
headers,
body: JSON.stringify({
accountAuthTokenToConnect: tokenToLink,
}),
},
);
if (!linkedDetailsResp.ok) {
const body = await linkedDetailsResp.json();
throw new Error(`Failed to link account: ${body.message || "Unknown"}`);
}
const { linkedAccounts } = await linkedDetailsResp.json();
return (linkedAccounts ?? []) satisfies Profile[];
}
/**
* @description
* Gets the linked accounts for the current user.
* For the public-facing API, use `wallet.getConnectedProfiles` instead.
*
* @internal
*/
export async function getLinkedProfilesInternal({
client,
}: { client: ThirdwebClient }): Promise<Profile[]> {
const IN_APP_URL = getThirdwebBaseUrl("inAppWallet");
const currentAccountToken = localStorage.getItem(
`walletToken-${client.clientId}`,
);
if (!currentAccountToken) {
throw new Error("Failed to get linked accounts, no user logged in");
}
const headers: Record<string, string> = {
"Content-Type": "application/json",
Authorization: `Bearer iaw-auth-token:${currentAccountToken}`,
"x-thirdweb-client-id": client.clientId,
};
const linkedAccountsResp = await fetch(
`${IN_APP_URL}/api/2024-05-05/accounts`,
{
method: "GET",
headers,
},
);
if (!linkedAccountsResp.ok) {
throw new Error(`Failed to get accounts: ${linkedAccountsResp.text}`);
}
const { linkedAccounts } = await linkedAccountsResp.json();
return (linkedAccounts ?? []) satisfies Profile[];
}
packages/thirdweb/src/wallets/in-app/core/authentication/type.ts → packages/thirdweb/src/wallets/in-app/core/authentication/types.ts
+12 -1
View File
@@ -1,7 +1,8 @@
import type { AuthType } from "@passwordless-id/webauthn/dist/esm/types.js";
import type { ThirdwebClient } from "../../../../client/client.js";
import type { Address } from "../../../../utils/address.js";
import type { Account } from "../../../interfaces/wallet.js";
import type { SocialAuthOption } from "../../../types.js";
import type { AuthOption, SocialAuthOption } from "../../../types.js";
import type { Ecosystem } from "../../web/types.js";
export type MultiStepAuthProviderType =
@@ -71,6 +72,16 @@ export type OauthOption = {
redirectUrl: string;
};
export type Profile = {
type: AuthOption;
details: {
id?: string;
email?: string;
phone?: string;
address?: Address;
};
};
/**
* @internal
*/
packages/thirdweb/src/wallets/in-app/core/interfaces/connector.ts
+13 -3
View File
@@ -1,23 +1,33 @@
import type { SocialAuthOption } from "../../../../wallets/types.js";
import type { Account } from "../../../interfaces/wallet.js";
import type {
AuthArgsType,
AuthLoginReturnType,
AuthStoredTokenWithCookieReturnType,
GetUser,
LogoutReturnType,
MultiStepAuthArgsType,
PreAuthArgsType,
SendEmailOtpReturnType,
} from "../authentication/type.js";
SingleStepAuthArgsType,
} from "../authentication/types.js";
export interface InAppConnector {
getUser(): Promise<GetUser>;
getAccount(): Promise<Account>;
preAuthenticate(args: PreAuthArgsType): Promise<SendEmailOtpReturnType>;
// Authenticate generates an auth token, when redirecting it returns void as the user is redirected to a new page and the token is stored in the callback url
authenticateWithRedirect?(strategy: SocialAuthOption): void;
// Login takes an auth token and connects a user with it
loginWithAuthToken?(
authResult: AuthStoredTokenWithCookieReturnType,
): Promise<AuthLoginReturnType>;
authenticate(args: AuthArgsType): Promise<AuthLoginReturnType>;
// Authenticate generates an auth token but does not log the user in
authenticate(
args: MultiStepAuthArgsType | SingleStepAuthArgsType,
): Promise<AuthStoredTokenWithCookieReturnType>;
// Connect is authenticate + login combined
connect(
args: MultiStepAuthArgsType | SingleStepAuthArgsType,
): Promise<AuthLoginReturnType>;
logout(): Promise<LogoutReturnType>;
}
packages/thirdweb/src/wallets/in-app/core/wallet/in-app-core.ts
+59 -2
View File
@@ -6,6 +6,15 @@ import type { Account, Wallet } from "../../../interfaces/wallet.js";
import { createWalletEmitter } from "../../../wallet-emitter.js";
import type { CreateWalletArgs } from "../../../wallet-types.js";
import type { Ecosystem } from "../../web/types.js";
import {
getLinkedProfilesInternal,
linkAccount as linkProfileWithToken,
} from "../authentication/linkAccount.js";
import type {
MultiStepAuthArgsType,
Profile,
SingleStepAuthArgsType,
} from "../authentication/types.js";
import type { InAppConnector } from "../interfaces/connector.js";
const connectorCache = new WeakMap<
@@ -56,6 +65,33 @@ export function createInAppWallet(args: {
},
getConfig: () => createOptions,
getAccount: () => account,
/**
* @description
* Gets the linked profiles for the current wallet.
* This method is only available for in-app or ecosystem wallets.
*
* @returns An array of accounts user profiles linked to the current wallet.
*
* @example
* ```ts
* import { inAppWallet } from "thirdweb/wallets";
*
* const wallet = inAppWallet();
* wallet.connect({ strategy: "google" });
*
* const profiles = wallet.getProfiles();
*
* console.log(profiles[0].type);
* console.log(profiles[0].details.email);
* ```
*/
getProfiles: async () => {
if (!client) {
return [];
}
return getLinkedProfilesInternal({ client });
},
autoConnect: async (options) => {
const { autoConnectInAppWallet } = await import("./index.js");
@@ -82,11 +118,11 @@ export function createInAppWallet(args: {
},
connect: async (options) => {
const { connectInAppWallet } = await import("./index.js");
const connector = await getOrCreateInAppWalletConnector(
options.client,
connectorFactory,
);
const [connectedAccount, connectedChain] = await connectInAppWallet(
options,
createOptions,
@@ -144,5 +180,26 @@ export function createInAppWallet(args: {
}
emitter.emit("chainChanged", newChain);
},
};
// This is not included on the global interface but is force-resolved in linkProfile
linkProfile: async (
options: SingleStepAuthArgsType | MultiStepAuthArgsType,
): Promise<Profile[]> => {
if (!client) {
throw new Error(
"No client found, please connect the wallet before linking a profile",
);
}
const connector = await getOrCreateInAppWalletConnector(
client,
connectorFactory,
);
const { storedToken } = await connector.authenticate(options);
return await linkProfileWithToken({
client,
tokenToLink: storedToken.cookieString,
});
},
} as Wallet<"inApp">;
}
packages/thirdweb/src/wallets/in-app/core/wallet/index.ts
+2 -2
View File
@@ -12,7 +12,7 @@ import type {
WalletAutoConnectionOption,
WalletConnectionOption,
} from "../../../wallet-types.js";
import { UserWalletStatus } from "../authentication/type.js";
import { UserWalletStatus } from "../authentication/types.js";
import type { InAppConnector } from "../interfaces/connector.js";
/**
@@ -52,7 +52,7 @@ export async function connectInAppWallet(
// IF WE EVER ADD MORE CONNECTOR TYPES, this could cause redirect to be ignored despite being specified
// TODO: In V6, make everything redirect auth
const authResult = await connector.authenticate(options);
const authResult = await connector.connect(options);
const authAccount = authResult.user.account;
if (
packages/thirdweb/src/wallets/in-app/core/wallet/profiles.ts
+74
View File
@@ -0,0 +1,74 @@
import type { Wallet } from "../../../interfaces/wallet.js";
import type {
MultiStepAuthArgsType,
Profile,
SingleStepAuthArgsType,
} from "../authentication/types.js";
/**
* @description
* Gets the linked profiles for the provided wallet.
* This method is only available for in-app wallets.
*
* @returns An array of accounts user profiles linked to the current wallet.
*
* @example
* ```ts
* import { inAppWallet } from "thirdweb/wallets";
*
* const wallet = inAppWallet();
* wallet.connect({ strategy: "google" });
*
* const profiles = await getProfiles(wallet);
*
* console.log(profiles[0].type);
* console.log(profiles[0].details.email);
* ```
*/
export async function getProfiles(wallet: Wallet<"inApp">) {
if (wallet.id !== "inApp") {
throw new Error("Multi-auth currently only supports in-app wallets");
}
return (
wallet as unknown as { getProfiles: () => Promise<Profile[]> }
).getProfiles();
}
/**
* @description
* Connects a new profile (authentication method) to the current user.
* The connected profile can be any valid in-app wallet including email, phone, passkey, etc.
* The inputs mirror those used when authenticating normally, @see {@link Wallet.connect}
*
* **When a profile is linked to the account, that profile can then be used to sign into the account.**
*
* This method is only available for in-app wallets.
*
* @param wallet - The wallet to link an additional profile to.
* @param auth - The authentications options to add the new profile.
* @returns A promise that resolves to the currently linked profiles when the connection is successful.
* @throws If the connection fails, if the profile is already linked to the account, or if the profile is already associated with another account.
*
* @example
* ```ts
* const wallet = inAppWallet();
*
* await wallet.connect({ strategy: "google" });
* const profiles = await linkProfile(wallet, { strategy: "discord" });
* ```
*/
export async function linkProfile(
wallet: Wallet<"inApp">,
auth: MultiStepAuthArgsType | SingleStepAuthArgsType,
): Promise<Profile[]> {
if (wallet.id !== "inApp") {
throw new Error("Multi-auth currently only supports in-app wallets");
}
return (
wallet as unknown as {
linkProfile: (authOptions: typeof auth) => Promise<Profile[]>;
}
).linkProfile(auth);
}
packages/thirdweb/src/wallets/in-app/core/wallet/types.ts
+1 -1
View File
@@ -6,7 +6,7 @@ import type {
AuthStoredTokenWithCookieReturnType,
MultiStepAuthArgsType,
SingleStepAuthArgsType,
} from "../authentication/type.js";
} from "../authentication/types.js";
export type InAppWalletConnectionOptions = (
| MultiStepAuthArgsType
packages/thirdweb/src/wallets/in-app/native/auth/index.ts
+2 -2
View File
@@ -5,7 +5,7 @@ import {
type GetAuthenticatedUserParams,
type PreAuthArgsType,
UserWalletStatus,
} from "../../core/authentication/type.js";
} from "../../core/authentication/types.js";
import { getOrCreateInAppWalletConnector } from "../../core/wallet/in-app-core.js";
// ---- KEEP IN SYNC WITH /wallets/in-app/web/lib/auth/index.ts ---- //
@@ -137,5 +137,5 @@ export async function authenticate(
args: AuthArgsType,
): Promise<AuthLoginReturnType> {
const connector = await getInAppWalletConnector(args.client);
return connector.authenticate(args);
return connector.connect(args);
}
packages/thirdweb/src/wallets/in-app/native/auth/native-auth.ts
+9 -3
View File
@@ -10,7 +10,7 @@ import {
type OauthOption,
RecoveryShareManagement,
type SendEmailOtpReturnType,
} from "../../core/authentication/type.js";
} from "../../core/authentication/types.js";
import {
deleteAccount,
fetchUserDetails,
@@ -204,7 +204,7 @@ export async function validateEmailOTP(options: {
}
}
export async function socialLogin(
export async function authenticate(
auth: OauthOption,
client: ThirdwebClient,
): Promise<AuthStoredTokenWithCookieReturnType> {
@@ -246,8 +246,14 @@ export async function socialLogin(
if (!authResult) {
throw new Error("No auth result found");
}
const { storedToken } = JSON.parse(authResult);
return JSON.parse(authResult);
}
export async function socialLogin(
auth: OauthOption,
client: ThirdwebClient,
): Promise<AuthStoredTokenWithCookieReturnType> {
const { storedToken } = await authenticate(auth, client);
try {
const toStoreToken: AuthStoredTokenWithCookieReturnType["storedToken"] = {
jwtToken: storedToken.jwtToken,
packages/thirdweb/src/wallets/in-app/native/helpers/api/fetchers.ts
+1 -1
View File
@@ -3,7 +3,7 @@ import type { ThirdwebClient } from "../../../../../client/client.js";
import type { Hex } from "../../../../../utils/encoding/hex.js";
import { getClientFetch } from "../../../../../utils/fetch.js";
import { randomBytesHex } from "../../../../../utils/random.js";
import type { UserDetailsApiType } from "../../../core/authentication/type.js";
import type { UserDetailsApiType } from "../../../core/authentication/types.js";
import {
ROUTE_EMBEDDED_WALLET_DETAILS,
ROUTE_IS_VALID_USER_MANAGED_OTP,
packages/thirdweb/src/wallets/in-app/native/helpers/auth/logout.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import type { LogoutReturnType } from "../../../core/authentication/type.js";
import type { LogoutReturnType } from "../../../core/authentication/types.js";
import {
removeAuthTokenInClient,
removeLoggedInWalletUserId,
packages/thirdweb/src/wallets/in-app/native/helpers/auth/middleware.ts
+1 -1
View File
@@ -3,7 +3,7 @@ import {
AuthProvider,
type AuthStoredTokenWithCookieReturnType,
RecoveryShareManagement,
} from "../../../core/authentication/type.js";
} from "../../../core/authentication/types.js";
import { ErrorMessages } from "../errors.js";
import {
getDeviceShare,
packages/thirdweb/src/wallets/in-app/native/helpers/storage/local.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import AsyncStorage from "@react-native-async-storage/async-storage";
import type { AuthArgsType } from "../../../core/authentication/type.js";
import type { AuthArgsType } from "../../../core/authentication/types.js";
import {
AUTH_TOKEN_LOCAL_STORAGE_NAME,
DEVICE_SHARE_LOCAL_STORAGE_NAME,
packages/thirdweb/src/wallets/in-app/native/helpers/types.ts
+1 -1
View File
@@ -1,7 +1,7 @@
import type {
AuthProvider,
RecoveryShareManagement,
} from "../../core/authentication/type.js";
} from "../../core/authentication/types.js";
export type VerifiedTokenResponse = {
verifiedToken: {
packages/thirdweb/src/wallets/in-app/native/helpers/wallet/creation.ts
+1 -1
View File
@@ -2,7 +2,7 @@ import { secp256k1 } from "@noble/curves/secp256k1";
import { publicKeyToAddress } from "viem/utils";
import type { ThirdwebClient } from "../../../../../client/client.js";
import { stringToHex, toHex } from "../../../../../utils/encoding/hex.js";
import type { SetUpWalletRpcReturnType } from "../../../core/authentication/type.js";
import type { SetUpWalletRpcReturnType } from "../../../core/authentication/types.js";
import { storeUserShares } from "../api/fetchers.js";
import { logoutUser } from "../auth/logout.js";
import {
packages/thirdweb/src/wallets/in-app/native/helpers/wallet/retrieval.ts
+1 -1
View File
@@ -6,7 +6,7 @@ import {
} from "../../../../../utils/encoding/hex.js";
import type { Account } from "../../../../interfaces/wallet.js";
import { privateKeyToAccount } from "../../../../private-key.js";
import type { SetUpWalletRpcReturnType } from "../../../core/authentication/type.js";
import type { SetUpWalletRpcReturnType } from "../../../core/authentication/types.js";
import { getUserShares } from "../api/fetchers.js";
import {
DEVICE_SHARE_MISSING_MESSAGE,
packages/thirdweb/src/wallets/in-app/native/native-connector.ts
+26 -5
View File
@@ -3,16 +3,18 @@ import type { Account } from "../../interfaces/wallet.js";
import {
type AuthArgsType,
type AuthLoginReturnType,
type AuthStoredTokenWithCookieReturnType,
type GetUser,
type LogoutReturnType,
type OauthOption,
type PreAuthArgsType,
type SendEmailOtpReturnType,
UserWalletStatus,
} from "../core/authentication/type.js";
} from "../core/authentication/types.js";
import type { InAppConnector } from "../core/interfaces/connector.js";
import {
authEndpoint,
authenticate,
customJwt,
deleteActiveAccount,
sendVerificationEmail,
@@ -89,18 +91,37 @@ export class InAppNativeConnector implements InAppConnector {
}
}
async authenticate(params: AuthArgsType): Promise<AuthLoginReturnType> {
async authenticate(
params: AuthArgsType,
): Promise<AuthStoredTokenWithCookieReturnType> {
const strategy = params.strategy;
switch (strategy) {
case "google":
case "facebook":
case "discord":
case "apple": {
const ExpoLinking = require("expo-linking");
const redirectUrl =
params.redirectUrl || (ExpoLinking.createURL("") as string);
return authenticate({ strategy, redirectUrl }, this.options.client);
}
default:
throw new Error(`Unsupported authentication type: ${strategy}`);
}
}
async connect(params: AuthArgsType): Promise<AuthLoginReturnType> {
const strategy = params.strategy;
switch (strategy) {
case "email": {
return await this.validateEmailOTP({
return await this.validateOtp({
email: params.email,
otp: params.verificationCode,
recoveryCode: params.verificationCode,
});
}
case "phone": {
return await this.validateEmailOTP({
return await this.validateOtp({
email: params.phoneNumber,
otp: params.verificationCode,
recoveryCode: params.verificationCode,
@@ -146,7 +167,7 @@ export class InAppNativeConnector implements InAppConnector {
}
}
private async validateEmailOTP(options: {
private async validateOtp(options: {
email: string;
otp: string;
recoveryCode?: string;
packages/thirdweb/src/wallets/in-app/web/lib/auth/abstract-login.ts
+4 -12
View File
@@ -4,7 +4,7 @@ import type {
AuthLoginReturnType,
AuthProvider,
SendEmailOtpReturnType,
} from "../../../core/authentication/type.js";
} from "../../../core/authentication/types.js";
import type { ClientIdWithQuerierType, Ecosystem } from "../../types.js";
import type { InAppWalletIframeCommunicator } from "../../utils/iFrameCommunication/InAppWalletIframeCommunicator.js";
@@ -28,11 +28,6 @@ export type LoginQuerierTypes = {
getHeadlessOauthLoginLink: { authProvider: AuthProvider };
};
type OauthLoginType = {
openedWindow?: Window | null;
closeOpenedWindow?: (openedWindow: Window) => void;
};
/**
* @internal
*/
@@ -90,10 +85,7 @@ export abstract class AbstractLogin<
encryptionKey: string;
}): Promise<AuthLoginReturnType>;
abstract loginWithModal(args?: MODAL): Promise<AuthLoginReturnType>;
abstract loginWithEmailOtp(args: EMAIL_MODAL): Promise<AuthLoginReturnType>;
abstract loginWithOauth(
args: OauthLoginType & { oauthProvider: AuthProvider },
): Promise<AuthLoginReturnType>;
abstract loginWithIframe(args: EMAIL_MODAL): Promise<AuthLoginReturnType>;
/**
* @internal
@@ -124,11 +116,11 @@ export abstract class AbstractLogin<
return result;
}
abstract verifyEmailLoginOtp(
abstract loginWithEmailOtp(
args: EMAIL_VERIFICATION,
): Promise<AuthLoginReturnType>;
abstract verifySmsLoginOtp(args: {
abstract loginWithSmsOtp(args: {
phoneNumber: string;
otp: string;
recoveryCode?: string;
packages/thirdweb/src/wallets/in-app/web/lib/auth/base-login.ts
+76 -178
View File
@@ -1,9 +1,7 @@
import {
type AuthAndWalletRpcReturnType,
type AuthLoginReturnType,
AuthProvider,
type GetHeadlessLoginLinkReturnType,
} from "../../../core/authentication/type.js";
import type {
AuthAndWalletRpcReturnType,
AuthLoginReturnType,
} from "../../../core/authentication/types.js";
import { AbstractLogin, type LoginQuerierTypes } from "./abstract-login.js";
/**
@@ -14,20 +12,12 @@ export class BaseLogin extends AbstractLogin<
{ email: string },
{ email: string; otp: string; recoveryCode?: string }
> {
private async getOauthLoginUrl(
authProvider: AuthProvider,
): Promise<GetHeadlessLoginLinkReturnType> {
try {
const result =
await this.LoginQuerier.call<GetHeadlessLoginLinkReturnType>({
procedureName: "getHeadlessOauthLoginLink",
params: { authProvider },
});
return result;
} catch (e) {
console.error(e);
throw e;
}
async authenticateWithModal(): Promise<AuthAndWalletRpcReturnType> {
return this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "loginWithThirdwebModal",
params: undefined,
showIframe: true,
});
}
/**
@@ -35,165 +25,42 @@ export class BaseLogin extends AbstractLogin<
*/
override async loginWithModal(): Promise<AuthLoginReturnType> {
await this.preLogin();
const result = await this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
const result = await this.authenticateWithModal();
return this.postLogin(result);
}
async authenticateWithIframe({
email,
}: {
email: string;
}): Promise<AuthAndWalletRpcReturnType> {
return this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "loginWithThirdwebModal",
params: undefined,
params: { email },
showIframe: true,
});
return this.postLogin(result);
}
/**
* @internal
*/
override async loginWithEmailOtp({
override async loginWithIframe({
email,
}: {
email: string;
}): Promise<AuthLoginReturnType> {
await this.preLogin();
const result = await this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "loginWithThirdwebModal",
params: { email },
showIframe: true,
});
const result = await this.authenticateWithIframe({ email });
return this.postLogin(result);
}
private closeWindow = ({
isWindowOpenedByFn,
win,
closeOpenedWindow,
}: {
win?: Window | null;
isWindowOpenedByFn: boolean;
closeOpenedWindow?: (openedWindow: Window) => void;
}) => {
if (isWindowOpenedByFn) {
win?.close();
} else {
if (win && closeOpenedWindow) {
closeOpenedWindow(win);
} else if (win) {
win.close();
}
}
};
private getOauthPopUpSizing(authProvider: AuthProvider) {
switch (authProvider) {
case AuthProvider.FACEBOOK:
return "width=715, height=555";
default:
return "width=350, height=500";
}
}
/**
* @internal
*/
override async loginWithOauth(args: {
oauthProvider: AuthProvider;
openedWindow?: Window | null | undefined;
closeOpenedWindow?: ((openedWindow: Window) => void) | undefined;
}): Promise<AuthLoginReturnType> {
let win = args?.openedWindow;
let isWindowOpenedByFn = false;
if (!win) {
win = window.open(
"",
"Login",
this.getOauthPopUpSizing(args.oauthProvider),
);
isWindowOpenedByFn = true;
}
if (!win) {
throw new Error("Something went wrong opening pop-up");
}
// logout the user
// fetch the url to open the login window from iframe
const [{ loginLink }] = await Promise.all([
this.getOauthLoginUrl(args.oauthProvider),
this.preLogin(),
]);
win.location.href = loginLink;
// listen to result from the login window
const result = await new Promise<AuthAndWalletRpcReturnType>(
(resolve, reject) => {
// detect when the user closes the login window
const pollTimer = window.setInterval(async () => {
if (!win) {
return;
}
if (win.closed) {
clearInterval(pollTimer);
window.removeEventListener("message", messageListener);
reject(new Error("User closed login window"));
}
}, 1000);
const messageListener = async (
event: MessageEvent<{
eventType: string;
authResult?: AuthAndWalletRpcReturnType;
error?: string;
}>,
) => {
if (event.origin !== this.baseUrl) {
return;
}
if (typeof event.data !== "object") {
reject(new Error("Invalid event data"));
return;
}
switch (event.data.eventType) {
case "userLoginSuccess": {
window.removeEventListener("message", messageListener);
clearInterval(pollTimer);
this.closeWindow({
isWindowOpenedByFn,
win,
closeOpenedWindow: args?.closeOpenedWindow,
});
if (event.data.authResult) {
resolve(event.data.authResult);
}
break;
}
case "userLoginFailed": {
window.removeEventListener("message", messageListener);
clearInterval(pollTimer);
this.closeWindow({
isWindowOpenedByFn,
win,
closeOpenedWindow: args?.closeOpenedWindow,
});
reject(new Error(event.data.error));
break;
}
case "injectDeveloperClientId": {
win?.postMessage(
{
eventType: "injectDeveloperClientIdResult",
developerClientId: this.client.clientId,
authOption: args.oauthProvider,
partnerId: this.ecosystem?.partnerId,
ecosystemId: this.ecosystem?.id,
},
this.baseUrl,
);
break;
}
}
};
window.addEventListener("message", messageListener);
},
);
return this.postLogin({
storedToken: { ...result.storedToken, shouldStoreCookieString: true },
walletDetails: { ...result.walletDetails, isIframeStorageEnabled: false },
async authenticateWithCustomJwt({
encryptionKey,
jwt,
}: LoginQuerierTypes["loginWithCustomJwt"]): Promise<AuthAndWalletRpcReturnType> {
return this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "loginWithCustomJwt",
params: { encryptionKey, jwt },
});
}
@@ -205,13 +72,20 @@ export class BaseLogin extends AbstractLogin<
jwt,
}: LoginQuerierTypes["loginWithCustomJwt"]): Promise<AuthLoginReturnType> {
await this.preLogin();
const result = await this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "loginWithCustomJwt",
params: { encryptionKey, jwt },
});
const result = await this.authenticateWithCustomJwt({ encryptionKey, jwt });
return this.postLogin(result);
}
async authenticateWithCustomAuthEndpoint({
encryptionKey,
payload,
}: LoginQuerierTypes["loginWithCustomAuthEndpoint"]): Promise<AuthAndWalletRpcReturnType> {
return this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "loginWithCustomAuthEndpoint",
params: { encryptionKey, payload },
});
}
/**
* @internal
*/
@@ -220,39 +94,63 @@ export class BaseLogin extends AbstractLogin<
payload,
}: LoginQuerierTypes["loginWithCustomAuthEndpoint"]): Promise<AuthLoginReturnType> {
await this.preLogin();
const result = await this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "loginWithCustomAuthEndpoint",
params: { encryptionKey, payload },
const result = await this.authenticateWithCustomAuthEndpoint({
encryptionKey,
payload,
});
return this.postLogin(result);
}
async authenticateWithEmailOtp({
email,
otp,
recoveryCode,
}: LoginQuerierTypes["verifyThirdwebEmailLoginOtp"]): Promise<AuthAndWalletRpcReturnType> {
return this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "verifyThirdwebEmailLoginOtp",
params: { email, otp, recoveryCode },
});
}
/**
* @internal
*/
override async verifyEmailLoginOtp({
override async loginWithEmailOtp({
email,
otp,
recoveryCode,
}: LoginQuerierTypes["verifyThirdwebEmailLoginOtp"]): Promise<AuthLoginReturnType> {
const result = await this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "verifyThirdwebEmailLoginOtp",
params: { email, otp, recoveryCode },
const result = await this.authenticateWithEmailOtp({
email,
otp,
recoveryCode,
});
return this.postLogin(result);
}
async authenticateWithSmsOtp({
phoneNumber,
otp,
recoveryCode,
}: LoginQuerierTypes["verifyThirdwebSmsLoginOtp"]): Promise<AuthAndWalletRpcReturnType> {
return this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "verifyThirdwebSmsLoginOtp",
params: { phoneNumber, otp, recoveryCode },
});
}
/**
* @internal
*/
override async verifySmsLoginOtp({
override async loginWithSmsOtp({
phoneNumber,
otp,
recoveryCode,
}: LoginQuerierTypes["verifyThirdwebSmsLoginOtp"]): Promise<AuthLoginReturnType> {
const result = await this.LoginQuerier.call<AuthAndWalletRpcReturnType>({
procedureName: "verifyThirdwebSmsLoginOtp",
params: { phoneNumber, otp, recoveryCode },
const result = await this.authenticateWithSmsOtp({
phoneNumber,
otp,
recoveryCode,
});
return this.postLogin(result);
}
packages/thirdweb/src/wallets/in-app/web/lib/auth/iframe-auth.ts
+35 -18
View File
@@ -5,7 +5,7 @@ import type {
AuthStoredTokenWithCookieReturnType,
LogoutReturnType,
SendEmailOtpReturnType,
} from "../../../core/authentication/type.js";
} from "../../../core/authentication/types.js";
import type { ClientIdWithQuerierType, Ecosystem } from "../../types.js";
import { LocalStorage } from "../../utils/Storage/LocalStorage.js";
import type { InAppWalletIframeCommunicator } from "../../utils/iFrameCommunication/InAppWalletIframeCommunicator.js";
@@ -129,6 +129,9 @@ export class Auth {
async loginWithModal(): Promise<AuthLoginReturnType> {
return this.BaseLogin.loginWithModal();
}
async authenticateWithModal(): Promise<AuthAndWalletRpcReturnType> {
return this.BaseLogin.authenticateWithModal();
}
/**
* Used to log the user into their thirdweb wallet using email OTP
@@ -148,10 +151,15 @@ export class Auth {
* @param args - args.email: We will send the email an OTP that needs to be entered in order for them to be logged in.
* @returns `{{user: InitializedUser}}` An InitializedUser object. See {@link InAppWalletSdk.getUser} for more
*/
async loginWithEmailOtp(
args: Parameters<BaseLogin["loginWithEmailOtp"]>[0],
async loginWithIframe(
args: Parameters<BaseLogin["loginWithIframe"]>[0],
): Promise<AuthLoginReturnType> {
return this.BaseLogin.loginWithEmailOtp(args);
return this.BaseLogin.loginWithIframe(args);
}
async authenticateWithIframe(
args: Parameters<BaseLogin["authenticateWithIframe"]>[0],
): Promise<AuthAndWalletRpcReturnType> {
return this.BaseLogin.authenticateWithIframe(args);
}
/**
@@ -162,6 +170,11 @@ export class Auth {
): Promise<AuthLoginReturnType> {
return this.BaseLogin.loginWithCustomJwt(args);
}
async authenticateWithCustomJwt(
args: Parameters<BaseLogin["authenticateWithCustomJwt"]>[0],
): Promise<AuthAndWalletRpcReturnType> {
return this.BaseLogin.authenticateWithCustomJwt(args);
}
/**
* @internal
@@ -171,19 +184,15 @@ export class Auth {
): Promise<AuthLoginReturnType> {
return this.BaseLogin.loginWithCustomAuthEndpoint(args);
}
/**
* @internal
*/
async loginWithOauth(
args: Parameters<BaseLogin["loginWithOauth"]>[0],
): Promise<AuthLoginReturnType> {
return this.BaseLogin.loginWithOauth(args);
async authenticateWithCustomAuthEndpoint(
args: Parameters<BaseLogin["authenticateWithCustomAuthEndpoint"]>[0],
): Promise<AuthAndWalletRpcReturnType> {
return this.BaseLogin.authenticateWithCustomAuthEndpoint(args);
}
/**
* A headless way to send the users at the passed email an OTP code.
* You need to then call {@link Auth.verifyEmailLoginOtp} in order to complete the login process
* You need to then call {@link Auth.loginWithEmailOtp} in order to complete the login process
* @example
* @param param0.email
* ```typescript
@@ -240,17 +249,25 @@ export class Auth {
* @returns `{{user: InitializedUser}}` An InitializedUser object containing the user's status, wallet, authDetails, and more
* @internal
*/
async verifyEmailLoginOtp(
args: Parameters<BaseLogin["verifyEmailLoginOtp"]>[0],
async loginWithEmailOtp(args: Parameters<BaseLogin["loginWithEmailOtp"]>[0]) {
return this.BaseLogin.loginWithEmailOtp(args);
}
async authenticateWithEmailOtp(
args: Parameters<BaseLogin["authenticateWithEmailOtp"]>[0],
) {
return this.BaseLogin.verifyEmailLoginOtp(args);
return this.BaseLogin.authenticateWithEmailOtp(args);
}
/**
* @internal
*/
async verifySmsLoginOtp(args: Parameters<BaseLogin["verifySmsLoginOtp"]>[0]) {
return this.BaseLogin.verifySmsLoginOtp(args);
async loginWithSmsOtp(args: Parameters<BaseLogin["loginWithSmsOtp"]>[0]) {
return this.BaseLogin.loginWithSmsOtp(args);
}
async authenticateWithSmsOtp(
args: Parameters<BaseLogin["authenticateWithSmsOtp"]>[0],
) {
return this.BaseLogin.authenticateWithSmsOtp(args);
}
/**
packages/thirdweb/src/wallets/in-app/web/lib/auth/index.ts
+2 -2
View File
@@ -6,7 +6,7 @@ import {
type GetAuthenticatedUserParams,
type PreAuthArgsType,
UserWalletStatus,
} from "../../../core/authentication/type.js";
} from "../../../core/authentication/types.js";
import { getOrCreateInAppWalletConnector } from "../../../core/wallet/in-app-core.js";
import type { Ecosystem } from "../../types.js";
@@ -158,5 +158,5 @@ export async function authenticate(
const connector = await getInAppWalletConnector(args.client, args.ecosystem);
if (args.redirect && connector.authenticateWithRedirect)
return connector.authenticateWithRedirect(args.strategy);
return connector.authenticate(args);
return connector.connect(args);
}
packages/thirdweb/src/wallets/in-app/web/lib/auth/oauth.ts
+1 -1
View File
@@ -1,8 +1,8 @@
import type { ThirdwebClient } from "../../../../../client/client.js";
import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
import type { AuthStoredTokenWithCookieReturnType } from "../../../../../wallets/in-app/core/authentication/type.js";
import type { SocialAuthOption } from "../../../../../wallets/types.js";
import { getSocialAuthLoginPath } from "../../../core/authentication/getLoginPath.js";
import type { AuthStoredTokenWithCookieReturnType } from "../../../core/authentication/types.js";
import type { Ecosystem } from "../../types.js";
import { DEFAULT_POP_UP_SIZE } from "./constants.js";
packages/thirdweb/src/wallets/in-app/web/lib/auth/passkeys.ts
+1 -1
View File
@@ -4,7 +4,7 @@ import type { ThirdwebClient } from "../../../../../client/client.js";
import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
import { getClientFetch } from "../../../../../utils/fetch.js";
import type { EcosystemWalletId } from "../../../../wallet-types.js";
import type { AuthStoredTokenWithCookieReturnType } from "../../../core/authentication/type.js";
import type { AuthStoredTokenWithCookieReturnType } from "../../../core/authentication/types.js";
import type { Ecosystem } from "../../types.js";
import { LocalStorage } from "../../utils/Storage/LocalStorage.js";
packages/thirdweb/src/wallets/in-app/web/lib/get-url-token.ts
+1 -1
View File
@@ -1,6 +1,6 @@
import type { AuthOption } from "../../../../wallets/types.js";
import type { WalletId } from "../../../wallet-types.js";
import type { AuthStoredTokenWithCookieReturnType } from "../../core/authentication/type.js";
import type { AuthStoredTokenWithCookieReturnType } from "../../core/authentication/types.js";
/**
* Checks for an auth token and associated metadata in the current URL
packages/thirdweb/src/wallets/in-app/web/lib/in-app-account.ts
+1 -1
View File
@@ -20,7 +20,7 @@ import {
type SetUpWalletRpcReturnType,
UserWalletStatus,
type WalletAddressObjectType,
} from "../../core/authentication/type.js";
} from "../../core/authentication/types.js";
import type {
ClientIdWithQuerierType,
Ecosystem,
packages/thirdweb/src/wallets/in-app/web/lib/web-connector.ts
+78 -13
View File
@@ -12,7 +12,7 @@ import {
type SendEmailOtpReturnType,
type SingleStepAuthArgsType,
UserWalletStatus,
} from "../../core/authentication/type.js";
} from "../../core/authentication/types.js";
import type { InAppConnector } from "../../core/interfaces/connector.js";
import type { InAppWalletConstructorType } from "../types.js";
import { InAppWalletIframeCommunicator } from "../utils/iFrameCommunication/InAppWalletIframeCommunicator.js";
@@ -104,7 +104,7 @@ export class InAppWebConnector implements InAppConnector {
}
/**
* Gets the usr if they are logged in
* Gets the user if they're logged in
* @example
* ```js
* const user = await thirdwebInAppWallet.getUser();
@@ -165,19 +165,90 @@ export class InAppWebConnector implements InAppConnector {
return this.auth.loginWithAuthToken(authResult);
}
/**
* Authenticates the user and returns the auth token, but does not instantiate their wallet
*/
async authenticate(
args: MultiStepAuthArgsType | SingleStepAuthArgsType,
): Promise<AuthStoredTokenWithCookieReturnType> {
const strategy = args.strategy;
switch (strategy) {
case "email":
return this.auth.authenticateWithEmailOtp({
email: args.email,
otp: args.verificationCode,
});
case "phone":
return this.auth.authenticateWithSmsOtp({
phoneNumber: args.phoneNumber,
otp: args.verificationCode,
});
case "jwt":
return this.auth.authenticateWithCustomJwt({
jwt: args.jwt,
encryptionKey: args.encryptionKey,
});
case "passkey":
if (args.type === "sign-up") {
return registerPasskey({
client: this.wallet.client,
ecosystem: this.wallet.ecosystem,
authenticatorType: args.authenticatorType,
username: args.passkeyName,
});
}
return loginWithPasskey({
client: this.wallet.client,
ecosystem: this.wallet.ecosystem,
authenticatorType: args.authenticatorType,
});
case "auth_endpoint": {
return this.auth.authenticateWithCustomAuthEndpoint({
payload: args.payload,
encryptionKey: args.encryptionKey,
});
}
case "iframe_email_verification": {
return this.auth.authenticateWithIframe({
email: args.email,
});
}
case "iframe": {
return this.auth.authenticateWithModal();
}
case "apple":
case "facebook":
case "google":
case "farcaster":
case "discord": {
return loginWithOauth({
authOption: strategy,
client: this.wallet.client,
ecosystem: this.wallet.ecosystem,
closeOpenedWindow: args.closeOpenedWindow,
openedWindow: args.openedWindow,
});
}
}
throw new Error("Unreachable");
}
/**
* Authenticates the user then instantiates their wallet using the resulting auth token
*/
async connect(
args: MultiStepAuthArgsType | SingleStepAuthArgsType,
): Promise<AuthLoginReturnType> {
const strategy = args.strategy;
switch (strategy) {
case "email": {
return await this.auth.verifyEmailLoginOtp({
return await this.auth.loginWithEmailOtp({
email: args.email,
otp: args.verificationCode,
});
}
case "phone": {
return await this.auth.verifySmsLoginOtp({
return await this.auth.loginWithSmsOtp({
otp: args.verificationCode,
phoneNumber: args.phoneNumber,
});
@@ -195,7 +266,7 @@ export class InAppWebConnector implements InAppConnector {
});
}
case "iframe_email_verification": {
return this.auth.loginWithEmailOtp({
return this.auth.loginWithIframe({
email: args.email,
});
}
@@ -225,14 +296,8 @@ export class InAppWebConnector implements InAppConnector {
case "farcaster":
case "telegram":
case "discord": {
const authToken = await loginWithOauth({
authOption: strategy,
client: this.wallet.client,
ecosystem: this.wallet.ecosystem,
closeOpenedWindow: args.closeOpenedWindow,
openedWindow: args.openedWindow,
});
return this.loginWithAuthToken(authToken);
const authToken = await this.authenticate(args);
return this.auth.loginWithAuthToken(authToken);
}
default:
packages/thirdweb/src/wallets/in-app/web/types.ts
+1 -1
View File
@@ -3,7 +3,7 @@
import type { ThirdwebClient } from "../../../client/client.js";
import type { EcosystemWalletId } from "../../wallet-types.js";
import type { AuthAndWalletRpcReturnType } from "../core/authentication/type.js";
import type { AuthAndWalletRpcReturnType } from "../core/authentication/types.js";
import type { InAppWalletIframeCommunicator } from "./utils/iFrameCommunication/InAppWalletIframeCommunicator.js";
export type Ecosystem = {
packages/thirdweb/src/wallets/interfaces/wallet.ts
+1
View File
@@ -74,6 +74,7 @@ export type Wallet<TWalletId extends WalletId = WalletId> = {
* ```
*/
getAccount(): Account | undefined;
/**
* Re-connect the wallet automatically without prompting the user for connection.
*