## **Mainnet endpoints** | | Public Endpoints | | --------------- | --------------------------------------- | | Network | Mainnet | | Chain Websocket | wss\://mainnet.ternoa.network | | Indexer |
| Contract Name | Address |
|---|---|
| PolygonZKevm Contract | 0x1F9942BfAB4f7a19d1e857dA8e60F98b23E15B4B |
| Bridge Contract | 0xF157F1f41eb8e161Dfa82E8792c740e9de2Ae5C8 |
| Rollup Manager Contract | 0x82f45dB8503a9a73CcaDAd37741105930dDc563a |
| Gas Token Contract | 0xe4a18Ae2258727e636eeE1290761895016644342 |
| DA Contract | 0xbc6c6513DE3aC2b0E947998ea4fAE626914E935b |
| ProxyAdmin | 0x95cC8654C48CA78e3Dd341253D9422FADBb77Af1 |
| PolygonZkEVMDeployer | 0x28AFA5B864Be24109BF2360319D81e850C00c73B |
| PolygonZkEVMGlobalExitRootL2 | 0xa62Bd3c5665a17F240E646127aDC0a1bBFDa5a05 |
| PolygonZkEVMTimelock | 0x44B8092e8E98bDc449312dcD4718686f4a477DAd |
# Ternoa indexer ### Overview⛓️ The indexer is an open, flexible, and fast tool based on the [**SubQuery Framework**](https://doc.subquery.network/)**.** It is used to transform blockchain data into a **graphql queryable database**. #### How it works: The indexer scans through each block and their events to see what happened on the Ternoa Blockchain. It then parses all that data into entities and inserts it in a Postgres DB. Ternoa deploys its indexer, and anybody can run his own. > You can get more information on the [**SubQuery official documentation**](https://doc.subquery.network/faqs/faqs.html) > You can also check out [**our repository**](https://github.com/capsule-corp-ternoa/ternoa-subql) to see how we set up the subquery project to connect to the ternoa blockchain. #### The most important files are: * Project.yaml: set up the endpoint, the genesis hash, the types file, and the different filters to get only the specific events / extrinsics needed. We can also filter on the success status of the event / extrinsic. * Schema.graphql: specifies the custom data we need to record in our Postgres db. * The Mappings folder: Your mappingHandlers will handle the functions to transform the blockchain data into the needed GraphQL entities contained in the Schema.graphql. More info [here](https://academy.subquery.network/build/mapping/polkadot.html) # Entities The entities listed below are all the entities handled in the indexer you can query, sorted by categories with the corresponding data: #### **TransferEntity:** * id * blockId * blockHash * extrinsicId * isSuccess * timestamp * from * to * currency * amount * amountRounded *** #### **CollectionEntity:** * id * collectionId * owner * offchainData * nfts * nbNfts * limit * hasReachedLimit * isClosed * timestampCreated * timestampBurned * timestampClosed * timestampLimited *** #### **NftEntity:** * id * nftId * auction * collection * owner * creator * offchainData * secretOffchainData * capsuleOffchainData * royalty * isCapsule * isCapsuleSynced * isSecret * isSecretSynced * delegatee * isDelegated * isSoulbound * isListed * typeOfListing * isRented * rentee * rentalContract * price * priceRounded * marketplace * isTransmission * transmissionRecipient * transmissionProtocol * createdAt * updatedAt * timestampCreated * timestampBurned * timestampListed * timestampRented * timestampSecretAdded * timestampConvertedToCapsule *** #### RentEntity * id * nftId * hasStarted * hasEnded * hasBeenCanceled * isExpired * renter * rentee * startBlockId * creationBlockId * durationType * blockDuration * maxSubscriptionBlockDuration * isSubscriptionChangeable * nextSubscriptionRenewalBlockId * nbSubscriptionRenewal * newTermsAvailable * nbTermsUpdate * acceptanceType * acceptanceList * renterCanRevoke * revokedBy * rentFeeType * rentFee * rentFeeRounded * rentOffers * nbRentOffers * totalRentOffersReceived * renterCancellationFeeType * renterCancellationFee * renterCancellationFeeRounded * renteeCancellationFeeType * renteeCancellationFee * renteeCancellationFeeRounded * timestampCreated * timestampStarted * timestampLastSubscriptionRenewal * timestampLastTermsUpdate * timestampLastOffer * timestampEnded * timestampCancelled * timestampRevoked * timestampExpired *** #### MarketplaceEntity * id * marketplaceId * owner * kind * commissionFeeType * commissionFee * commissionFeeRounded * listingFeeType * listingFee * listingFeeRounded * accountList * offchainData * collectionList * createdAt * updatedAt * timestampCreated *** #### AuctionEntity * id * nftId * marketplaceId * creator * startPrice * startPriceRounded * buyItNowPrice * buyItNowPriceRounded * startBlockId * endBlockId * isCompleted * isCancelled * isExtendedPeriod * bidders * nbBidders * topBidAmount * topBidAmountRounded * typeOfSale * timestampCreated * timestampEnded * timestampLastBid * timestampCancelled *** #### AccountEntity * id * capsAmount * capsAmountFrozen * capsAmountTotal * capsAmountRounded * capsAmountFrozenRounded * capsAmountTotalRounded * createdAt * updatedAt *** #### TransmissionEntity: * id * nftId * from * to * isActive * isThresholdReached * protocol * endBlock * consentList * currentConsent * threshold * cancellation * cancellationBlock * createdAt * updatedAt * timestampCreated * timestampRemoved * timestampUpdated * timestampTransmitted # Start to query # Using a playground ### Use it from the playground Depending on the data you are looking for, you can directly query any data needed on: * [**The Alphanet indexer**](https://indexer-alphanet.ternoa.dev/) * [**The Mainnet indexer**](https://indexer-mainnet.ternoa.network/) You just need to create the graphql request, for example, a simple request to get the 10 last listed nft: ```graphql { nftEntities(first: 10, offset: 0, orderBy: TIMESTAMP_LIST_DESC) { totalCount nodes { nftId owner creator collectionId offchainData } } } ``` **The same example in the playground:**
```bash cargo test ``` \ The command should compile the program and display output similar to the following to indicate successful test completion:
``` running 2 tests test flipper::tests::it_works ... ok test flipper::tests::default_works ... ok test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` #### Build the contract After testing the default contract, you are ready to compile this project to WebAssembly. To build the WebAssembly for this smart contract: 1. Open a terminal shell on your computer, if needed. 2. Verify that you are in the `flipper` project folder. 3. Compile the `flipper` smart contract by running the following command:
cargo contract build
```bash substrate-contracts-node --log info,runtime::contracts=debug 2>&1 ``` \ The extra logging is useful for development. \ You should see output in the terminal similar to the following: ``` 2023-01-30 23:08:49.835 INFO main sc_cli::runner: Substrate Contracts Node 2023-01-30 23:08:49.836 INFO main sc_cli::runner: ✌️ version 0.23.0-87a3d76c880 2023-01-30 23:08:49.836 INFO main sc_cli::runner: ❤️ by Parity Technologies
```bash cargo contract instantiate --constructor new --args "false" --suri //Alice --salt $(date +%s) -x ``` \ Some notes about the command: * The `instantiate` command will do both the `upload` and `instantiate` steps for you. * We need to specify the contract constructor to use, which in this case is `new()` * We need to specify the argument to the constructor, which in this case is `false` * We need to specify the account uploading and instantiating the contract, which in this case is the default development account of `//Alice` * During development, we may want to upload the instantiate of the same contract multiple times, so we specify a `salt` using the current time. Note that this is optional. After running the command confirming that we're happy with the gas estimation we should see something like this:
``` Dry-running new (skip with --skip-dry-run) Success! Gas required estimated at Weight(ref_time: 328660939, proof_size: 0) Confirm transaction details: (skip with --skip-confirm) Constructor new Args false Gas limit Weight(ref_time: 328660939, proof_size: 0) Submit? (Y/n): Events Event Balances ➜ Withdraw who: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY amount: 98.986123μUNIT Event System ➜ NewAccount account: 5GRAVvuSXx8pCpRUDHzK6S1r2FjadahRQ6NEgAVooQ2bB8r5 ... snip ... Event TransactionPayment ➜ TransactionFeePaid who: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY actual_fee: 98.986123μUNIT tip: 0UNIT Event System ➜ ExtrinsicSuccess dispatch_info: DispatchInfo { weight: Weight { ref_time: 2827629132, proof_size: 0 }, class: Normal, pays_fee: Yes } Contract 5GRAVvuSXx8pCpRUDHzK6S1r2FjadahRQ6NEgAVooQ2bB8r5 ``` We will need the `Contract` address to `call` the contract, so make sure you don't lose it. ### Calling the Deployed ink! Contract We can not only `upload` and `instantiate` contracts using `cargo-contract`, we can also `call` them! #### `get()` Message When we initialized the contract we set the initial value of the `flipper` to `false`. We can confirm this by calling the `get()` message. Since we are only reading from the blockchain state (we're not writing any new data) we can use the `--dry-run` flag to avoid submitting an extrinsic. ```bash cargo contract call --contract $INSTANTIATED_CONTRACT_ADDRESS --message get --suri //Alice --dry-run ``` Some notes about the command: * The address of the contract we want to call has to be specified using the `--contract` flag. Replace `$INSTANTIATED_CONTRACT_ADDRESS` with the contract address created at the end of the build. * This can be found in the output logs of the `cargo contract instantiate` command * We need to specify the contract message to use, which in this case is `get()` * We need to specify the account calling the contract, which in this case is the default development account of `//Alice` * We specify `--dry-run` to avoid submitting an extrinsic on-chain After running the command should see something like this: ``` Result Success! Reverted false Data Tuple(Tuple { ident: Some("Ok"), values: [Bool(false)] }) ``` We're interested in the `value` here, which is `false` as expected. #### `flip()` Message The `flip()` message changes the storage value from `false` to `true` and vice versa. To call the `flip()` message we will need to submit an extrinsic on-chain because we are altering the state of the blockchain. To do this we can use the following command: ```bash cargo contract call --contract $INSTANTIATED_CONTRACT_ADDRESS --message flip --suri //Alice ``` Notice that we changed the message to `flip` and removed the `--dry-run` flag. After running we expect to see something like: ``` Dry-running flip (skip with --skip-dry-run) Success! Gas required estimated at Weight(ref_time: 8013742080, proof_size: 262144) Confirm transaction details: (skip with --skip-confirm) Message flip Args Gas limit Weight(ref_time: 8013742080, proof_size: 262144) Submit? (Y/n): Events Event Balances ➜ Withdraw who: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY amount: 98.974156μUNIT Event Contracts ➜ Called caller: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY contract: 5GQwxP5VTVHwJaRpoQsK5Fzs5cERYBzYhgik8SX7VAnvvbZS Event TransactionPayment ➜ TransactionFeePaid who: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY actual_fee: 98.974156μUNIT tip: 0UNIT Event System ➜ ExtrinsicSuccess dispatch_info: DispatchInfo { weight: Weight { ref_time: 1410915697, proof_size: 13868 }, class: Normal, pays_fee: Yes } ``` If we call the `get()` message again we can see that the storage value was indeed flipped! ``` Result Success! Reverted false Data Tuple(Tuple { ident: Some("Ok"), values: [Bool(true)] }) ``` # Introduction In this section, you will find a high level overview of Ternoa's architecture, networks and purpose. ## ## ## # What is Ternoa [Ternoa](https://www.ternoa.network/) is a multi-network and cross-layer protocol leveraging confidential computing technologies to make blockchain more secure, private and scalable. Our tech stack combines distributed ledger and confidential computing technologies to provide decentralized yet private development environments for next generation applications. Ternoa comprises of 3 independent, yet interconnected networks: * **Ternoa Chain**: A WASM Layer 1 blockchain network built on Substrate where builders can deploy ink! smartcontracts coded in Rust, C, C++ or Typescript, and call pre-coded primitives through a JavaScript SDK (mainnet since April 2022) * **Ternoa Fortress**: A decentralized TEE-powered coprocessor network, implemented as a key management system, enabling users to encrypt off-chain data with on-chain encryption keys (mainnet since September 2023) * **Ternoa zkEVM**: A Layer 2 validium secured with TEE multi-proofs, offering a full EVM equivalent environment where builders can deploy solidity smartcontracts (mainnet planned for 2024) Since the beginning Ternoa has been envisioned as a comprehensive protocol enabling new privacy and security use cases. Our TEE-powered tech stack has been live and available as a mainnet L1 since 2022, prompting us to develop a multi-layer and multi-chain architecture, set for delivery in 2024. # Why build on Ternoa **ACCESSIBILITY** Our tech stack has been designed to cater to the needs of the greatest number of developers. Regardless of your background, or of the type of application you are looking to build, you will find a suitable dev environment to launch your project. * On Ternoa, **new developers** making their first steps in web3 don’t need to learn how to write smart contracts to develop blockchain applications. Our javascript SDK enables this and makes Ternoa suitable for web2 audiences just entering web3, including corporations & organizations. * **Seasoned Web3 developers** can deploy WASM smartcontracts on Ternoa Chain written in Rust, C, C++, or Typescript. And will soon be able to build EVM dapps in Solidity. Our smartcontract environments enable the most complex use cases to be built on our infrastructure, and take advantage of our built-in confidentiality features and security. **BUILT-IN CONFIDENTIALITY FEATURES** For developers and dapps with a need to secure, control access and transmit confidential data without relying on 3rd parties or tech platform. Ternoa natively offers privacy features through the Fortress, our decentralized key management system. Enabling developers to create and compose private yet trustless applications very easily. Builders and users can interact with the Fortress via Ternoa Chain today. The Fortress will also become accessible from Ternoa zkEVM once launched.
**SECURITY** Ternoa Chain is built with Substrate, an open-source, thoroughly audit framework powered by state of the art Proof of Stake consensus. Our network is decentralized by hundreds of nodes and validators. And our architecture makes us natively compatible to rely upon Polkadot's network security. Ternoa zkEVM combines zero knowledge proofs with additional TEE proofs to achieve enhanced levels of network security. ## Networks Purpose Each of Ternoa's network serve the shared goal of making internet a more decentralized and private place , and play a specific role in this grand scheme:
| Network | Purpose | Specifics |
|---|---|---|
| Ternoa Fortress | Enable data privacy and decentralized security | The Fortress is a TEE coprocessor network, fully open source, with native key management features |
| Ternoa Chain | Facilitate the onboarding of web and web2 builders in Web3 | Ternoa Chain brings in a WASM deployment environment for smartcontracts, as well as pre-coded primitives accessible with Javascript |
| Ternoa ZKEVM | Bring in enhanced TEE security to zkEVM, and make Ternoa ecosystem accessible natively from ethereum | Ternoa ZKEVM is a validium using TEE proofs to add a layer of security to zkEVM, and is fully ethereum equivalent |
Figure 1: Core components of Ternoa Blockchain
P2P Synchronization: Inter-Cluster Replication
Mutual Remote Attestation
# Secret NFT NFTs (Non-Fungible Tokens) have gained popularity as a way to represent ownership of unique digital assets. They are often associated with blockchain technology where ownership records are transparent and cannot be duplicated or forged. In the context of a network society, shared economy, and decentralized identities, NFTs play a role in redefining ownership and enabling partial, temporary, and delegated shared ownership of digital assets. This means that ownership of an NFT can be transferred or shared among multiple parties, and it can also include time-limited access rights. As the world becomes more connected with autonomous AI-powered IoT devices, managing assets, including keys, becomes crucial. This implies that in addition to managing the ownership of digital assets through NFTs, effective key management methods should be considered to maintain security and control over these assets. While NFTs use decentralized technology, DKMS refers to the secure storage and management of cryptographic keys in a decentralized manner. NFTs and DKMS are used together to enable secure and transparent ownership and transfer of digital assets. However, it’s important to note NFTs themselves are not a direct application of DKMS. Instead, DKMS can be utilized to enhance the security and privacy aspects of NFT ownership. DKMS can be used to add confidentiality to NFTs by enabling secure and private ownership of the NFT media content: 1\. Generation of Keys: Each user generates a pair of cryptographic keys — a public key and a private key. The private key is kept secret and is used to sign transactions, while the public key is shared publicly. 2\. Ownership Verification: When an NFT is created, its ownership is associated with the owner’s public key. This linkage is stored on the blockchain or decentralized ledger, making it publicly verifiable. 3\. Confidential Transactions: The private key allows the owner to prove ownership and transfer the NFT without revealing their identity or sensitive information. The transfer can be cryptographically signed with the private key and broadcast to the network. 4\. Decentralized Storage: The NFT’s metadata and ownership details can be stored decentrally, ensuring resilience and availability without relying on a single point of failure. 5\. Extensibility: Each confidential NFT can contain another private key, source code, or NFT for more complex applications.
On-chain and off-chain components of Ternoa Secret NFT protocol
Proactive Verifiable Secret Sharing
{% hint style="info" %} If you're new to the Ternoa JavaScript builder ecosystem, we strongly suggest starting with the [Getting Started](/) introduction track. It will not only give you the necessary prerequisites but also aid in comprehending some vital architectural concepts for efficient building. Provide a specific focus to the following sections: Ternoa-js [architecture](/getting-started/javascript-sdk/ternoa-js-library/architecture), [events](/getting-started/javascript-sdk/ternoa-js-library/blockchain-events), and [workflow](/getting-started/javascript-sdk/ternoa-js-library/workflow). {% endhint %} If you are looking for a way to kickstart your builder journey, you should start interacting with the Ternoa-js SDK and Indexer with our [NODE-JS quickstart guide ](/getting-started/javascript-sdk/quickstart-node-js)🏁[.](/getting-started/javascript-sdk/quickstart-node-js) # Handling wallets & accounts # Ternoa wallet & Wallet connect ### **Introduction** **Ternoa Wallet** is a non-custodial crypto wallet created and maintained by **Ternoa**. Powered by React-Native and Polkadot.js, it is built on top of the Ternoa ecosystem to allow users to manage their CAPS and NFTs on the Mainnet and Alphanet networks. {% hint style="info" %} #### Download Ternoa Wallet: [On the PlayStore](https://play.google.com/store/apps/details?id=com.ternoa.wallet.prod###)\ [On the App Store](https://apps.apple.com/us/app/ternoa-wallet/id1562180877#?platform=iphone/) {% endhint %} > To learn more about creating a Ternoa Wallet, look at [this section](/getting-started/wallets/ternoa-wallet) first. ### Prerequisites Before getting started, please ensure that you have the following prerequisites in place: 1. [Create a Ternoa account](/getting-started/wallets/ternoa-wallet) with [Alphanet CAPS](broken://pages/ej9gceaLIhCN2PgUBh42) from the [faucet.](https://faucet.ternoa.network/) 2. Install and configure your preferred code editor (for this tutorial, we will be using Visual Studio Code \[VSC]). 3. Install [NodeJS v.14+](https://nodejs.org/en/download/), along with NPM. {% hint style="info" %} We assume you have already created a new wallet for development purposes with no CAPS on Ternoa Mainnet. You must use a development wallet with *NO REAL MONEY* in it when learning, practicing, and testing. {% endhint %} This documentation is aimed at helping developers who create dApps leveraging the Ternoa ecosystem to integrate Ternoa Wallet and Wallet Connect. ### Getting Started The simplest way to quickstart jumping into Ternoa Wallet and Wallet Connect to build on the blockchain is to look at the starter repository [here](https://github.com/capsule-corp-ternoa/ternoa-wallet?tab=readme-ov-file), and start our tutorial: On that [repository](https://github.com/capsule-corp-ternoa/ternoa-wallet?tab=readme-ov-file), you will find the following useful resources that will help you with the integration: * [Tutorial](https://github.com/capsule-corp-ternoa/ternoa-wallet/blob/main/wallet-connect-integration/TUTORIAL.md): A step-by-step guide * [dApp-example](https://github.com/capsule-corp-ternoa/ternoa-wallet/blob/main/wallet-connect-integration/dapp-example) ([JS](https://github.com/capsule-corp-ternoa/ternoa-wallet/blob/main/wallet-connect-integration/dapp-example) / [TS](https://github.com/capsule-corp-ternoa/ternoa-wallet/blob/main/wallet-connect-integration/dapp-example-ts)): A boilerplate app * [QR Scan, Deeplink, and Webview](https://github.com/capsule-corp-ternoa/ternoa-wallet/blob/main/wallet-connect-integration/CONNECTION.md): The 3 different ways to connect * [Transaction request object](https://github.com/capsule-corp-ternoa/ternoa-wallet/blob/main/wallet-connect-integration/REQUEST.md): How to send transactions or sign a message ### Issues If you are experiencing an issue with Ternoa Wallet, please visit the [issues section](https://github.com/capsule-corp-ternoa/ternoa-wallet/issues). If the issue you are experiencing has not yet been reported, create a new issue. ### Support If you face any trouble, feel free to reach out to our community engineers in our [Discord](https://discord.gg/fUmBkPpnRu). # Access your account through a seed & a keyring ### Prerequisites Before getting started, please ensure that you have the following prerequisites in place: 1. [Create a Ternoa account](/getting-started/wallets/ternoa-wallet) with [Alphanet CAPS](broken://pages/ej9gceaLIhCN2PgUBh42) from the [faucet.](https://faucet.ternoa.network/) 2. Install and configure your preferred code editor (for this tutorial, we will be using Visual Studio Code \[VSC]). 3. Install [NodeJS v.14+](https://nodejs.org/en/download/), along with NPM. {% hint style="success" %} If you are not familiar with the process of creating a transaction on the Ternoa chain, we highly suggest first reading the Getting Started section of the documentation with a focus on the [Ternoa-js workflow](/getting-started/javascript-sdk/ternoa-js-library/workflow) and the two transaction [approaches](/getting-started/javascript-sdk/ternoa-js-library/workflow#to-build-applications-within-the-ternoa-sdk-we-provide-two-approaches-for-each-primitive-extrinsic). {% endhint %} Most of our examples in this documentation use the **automated approach** and involve creating the Keyring to sign and submit a transaction. {% hint style="info" %} Polkadot ***Keyring's*** definition: *The Keyring allows you to manage a set of keys in a consistent environment, allows you to perform operations on these keys (such as sign/verify), and never exposes the secretKey to the outside world.*\ \ Learn more on keyring in the[ Polkadot's documentation.](https://polkadot.js.org/docs/keyring) {% endhint %} ### Generating a keyring {% hint style="warning" %} We assume you have already created a new wallet for development purposes with no CAPS on Ternoa Mainnet. You must use a development wallet with *NO REAL MONEY* in it when learning, practicing, and testing.\ \ **The 12 worlds' seeds must be stored in a .env.variable file. Be sure to NEVER make your seed publicly accessible or visible in a browser.** {% endhint %} ```typescript import { initializeApi, getKeyringFromSeed } from "ternoa-js"; const main = async () => { try { await initializeApi(); const ACCOUNT_SEED = "REPLACE_WITH_YOUR_SEED"; // 12 worlds seed const keyring = await getKeyringFromSeed(ACCOUNT_SEED); console.log(`The keyring address is ${keyring.address}`); process.exit(0) } catch (e) { console.error(e); process.exit(1) } finally { process.exit(0) } }; main(); ``` You can now provide your keyring as function parameters to create some transactions like we do to [mint an NFT.](/build-1/javascript/nft-features-and-pallets/basics-nft-and-collections/nft/mint-a-basic-nft) \ \ See more examples in the [NFT features & Pallets section. ](/build-1/javascript/nft-features-and-pallets) # Connect with Polkadot extension ### Prerequisites Before getting started, please ensure that you have the following prerequisites in place: 1. [Import your Ternoa account](https://docs.ternoa.network/build-1/javascript/wallets/pages/74OQM5fJ55PU0jJHPDl4#how-to-connect-your-ternoa-account-on-polkadot-.js) in the Polkadot{.js} extension, or [create an account in the extension ](/getting-started/wallets/polkadot-extension)directly. 2. Install and configure your preferred code editor (for this tutorial, we will be using Visual Studio Code \[VSC]). 3. Install [NodeJS v.14+](https://nodejs.org/en/download/), along with NPM. #### Utilizing Polkadot extension, Next.js, and TypeScript: In the code snippet below, we cover how to connect to the @polkadot/extension-dapp and fetch your accounts registered in your Polkadot browser extension (it will also fetch all substrate accounts registered in the other browser extensions). Please, note that this solution is not the only one. **Feel free to use any provider that would suit best your dApp.** *This code snipped is designed to work in a **Next-js environment**. According to Next-js server-side components rules, the import of the @polkadot/extension-dapp extension library might need to be slightly adapted to work in your javascript environment.* ```typescript export const getAccounts = async () => { const { web3Accounts, web3Enable } = await import("@polkadot/extension-dapp"); const extensions = await web3Enable("Name your dApp powered by Ternoa"); if (extensions.length === 0) throw new Error( 'polkadot{.js} extension might not be installed. Make sure you allowed the dApp in the "Manage Website Access" settings of your wallet.' ); return await web3Accounts(); }; ``` {% hint style="info" %} You can implement this **atomic function** in your repository. {% endhint %} Now you can access the accounts, you can fetch them when needed, and store the index of the account you want to set as the connected account in your storage solution (context, redux, or any solution you use). ### Next The next step will be to [sign a transaction in a browser environment](/build-1/javascript/ternoa-js-library-utilities/sign-a-transaction-with-polkadot-.js-extension-in-a-browser-environment). You can also look at how to [mint an NFT](/build-1/javascript/ternoa-js-library-utilities/sign-a-transaction-with-polkadot-.js-extension-in-a-browser-environment) or a [secret NFT](/build-1/javascript/privacy-protocols/tee-privacy-and-encryption/encryption-in-browser-with-wallet-and-extension) with your extension. --- [Next Page](/llms-full.txt/1)