From 3ccd32592ab3114f785293fe62c9f5099b95b92a Mon Sep 17 00:00:00 2001 From: Bri Wylde <92327786+briwylde08@users.noreply.github.com> Date: Fri, 22 Dec 2023 09:25:28 -0700 Subject: [PATCH] Adding Soroban to Stellar Fundamentals (#269) * Networks * formatting * update ledger section * update asset section * adding details to Soroban operations * markdown linting for the list-of-operations page * update Lumens section to include smart contract data * network additions to include Futurenet * edit to accounts page I'm iffy on if this one makes sense. Is smart contract data even relevant to account subentries? Is it assumed that we're not talking about smart contract data? Is it confusing to call out? To be discussed. * quick addition to Assets section * starting on the stack * update RPC for Futurenet * updating stellar stack to include Soroban components * starting on operations and transactions -move transaction lifecycle to new section under F&C -remove transaction lifecycle from operations & transactions * updated stack image * update ledger * other network edits * more on operations & transactions * docs: first stab at a "contract" data structure page... meh * added bit about resource limitations * small copy tweaks * Update docs/fundamentals-and-concepts/lumens.mdx Co-authored-by: George * Update docs/fundamentals-and-concepts/networks.mdx Co-authored-by: George * Update docs/fundamentals-and-concepts/networks.mdx Co-authored-by: George * Update docs/fundamentals-and-concepts/list-of-operations.mdx expand TTL acronym, point that `extendTo` is an absolute sequence number. Co-authored-by: George * docs: swap persistent/instance storage add note about abstraction * note the `extendTo` parameter is an absolute seq number, not relative * add redirect for networks page * docs: add description of "soroban" in "smart contracts" page * Update docs/fundamentals-and-concepts/lumens.mdx Co-authored-by: Elliot Voris * Update docs/fundamentals-and-concepts/lumens.mdx Co-authored-by: Elliot Voris * Update docs/fundamentals-and-concepts/stellar-data-structures/assets.mdx Co-authored-by: Elliot Voris * Update docs/fundamentals-and-concepts/stellar-data-structures/operations-and-transactions.mdx Co-authored-by: Elliot Voris * Update docs/fundamentals-and-concepts/stellar-data-structures/operations-and-transactions.mdx Co-authored-by: Elliot Voris * Update docs/fundamentals-and-concepts/transaction-lifecycle.mdx Co-authored-by: Elliot Voris * fix link for state archival, include bit about instance storage * update networks * transaction lifecycle disclaimer * Update docs/fundamentals-and-concepts/lumens.mdx Co-authored-by: Justin Rice * Update docs/fundamentals-and-concepts/networks.mdx Co-authored-by: Justin Rice * Update docs/fundamentals-and-concepts/networks.mdx Co-authored-by: Justin Rice * Update docs/fundamentals-and-concepts/stellar-data-structures/contracts.mdx Co-authored-by: Justin Rice * Update docs/fundamentals-and-concepts/stellar-data-structures/contracts.mdx Co-authored-by: Justin Rice * rent and asset edits * Update docs/fundamentals-and-concepts/stellar-stack.mdx Co-authored-by: Justin Rice * formatting * Update docs/fundamentals-and-concepts/stellar-stack.mdx Co-authored-by: Justin Rice --------- Co-authored-by: Elliot Voris Co-authored-by: George Co-authored-by: Justin Rice --- api/horizon/introduction/index.mdx | 2 +- .../list-of-operations.mdx | 58 +++++++++- docs/fundamentals-and-concepts/lumens.mdx | 10 +- docs/fundamentals-and-concepts/networks.mdx | 103 ++++++++++++++++++ .../stellar-data-structures/accounts.mdx | 2 +- .../stellar-data-structures/assets.mdx | 8 ++ .../stellar-data-structures/contracts.mdx | 58 ++++++++++ .../stellar-data-structures/ledgers.mdx | 2 +- .../operations-and-transactions.mdx | 62 ++--------- .../stellar-stack.mdx | 35 +++++- .../testnet-and-pubnet.mdx | 87 --------------- .../transaction-lifecycle.mdx | 58 ++++++++++ docs/glossary.mdx | 10 +- docs/issuing-assets/how-to-issue-an-asset.mdx | 2 +- docs/run-core-node/configuring.mdx | 2 +- docs/tutorials/create-account.mdx | 2 +- nginx/includes/redirects.conf | 1 + static/assets/updated-stellar-stack.png | Bin 0 -> 25157 bytes 18 files changed, 338 insertions(+), 164 deletions(-) create mode 100644 docs/fundamentals-and-concepts/networks.mdx create mode 100644 docs/fundamentals-and-concepts/stellar-data-structures/contracts.mdx delete mode 100644 docs/fundamentals-and-concepts/testnet-and-pubnet.mdx create mode 100644 docs/fundamentals-and-concepts/transaction-lifecycle.mdx create mode 100644 static/assets/updated-stellar-stack.png diff --git a/api/horizon/introduction/index.mdx b/api/horizon/introduction/index.mdx index 29b65ce07..d82ca97e5 100644 --- a/api/horizon/introduction/index.mdx +++ b/api/horizon/introduction/index.mdx @@ -16,7 +16,7 @@ Horizon is a [RESTful API](https://en.wikipedia.org/wiki/Representational_state_ The Stellar Development Foundation (SDF) runs two instances of Horizon: - [https://horizon.stellar.org/](https://horizon.stellar.org/) for interacting with the public network -- [https://horizon-testnet.stellar.org/](https://horizon-testnet.stellar.org/) for interacting with the [testnet](/docs/fundamentals-and-concepts/testnet-and-pubnet) +- [https://horizon-testnet.stellar.org/](https://horizon-testnet.stellar.org/) for interacting with the [testnet](/docs/fundamentals-and-concepts/networks) diff --git a/docs/fundamentals-and-concepts/list-of-operations.mdx b/docs/fundamentals-and-concepts/list-of-operations.mdx index a0e73fdf7..cf27e4315 100644 --- a/docs/fundamentals-and-concepts/list-of-operations.mdx +++ b/docs/fundamentals-and-concepts/list-of-operations.mdx @@ -685,7 +685,26 @@ Note that Soroban transactions can only contain one operation per transaction. Learn more in the [Soroban docs](https://soroban.stellar.org/docs/fundamentals-and-concepts/invoking-contracts-with-transactions#invokehostfunctionop). -## Bump Footprint Expiration +**Threshold**: Medium +**Result**: `InvokeHostFunctionResult` +**Parameters**: + +| Parameters | Type | Description | +| --- | --- | --- | +| Host Function | HostFunction | The host function to invoke | +| Auth | Soroban Authorization Entry | Per-address authorizations for this host function. | + +**Possible errors**: + +| Error | Code | Description | +| --- | --- | --- | +| INVOKE_HOST_FUNCTION_MALFORMED | -1 | One or more of the inputs to the operation was malformed. | +| INVOKE_HOST_FUNCTION_TRAPPED | -2 | The function invocation trapped in the Soroban runtime. | +| INVOKE_HOST_FUNCTION_RESOURCE_LIMIT_EXCEEDED | -3 | The function invocation could not complete within the currently configured resource constraints of the network. | +| INVOKE_HOST_FUNCTION_ENTRY_ARCHIVED | -4 | A ledger entry required for this function's footprint is in an archived state, and must be restored. | +| INVOKE_HOST_FUNCTION_INSUFFICIENT_REFUNDABLE_FEE | -5 | The refundable Soroban fee provided was not sufficient to pay for the compute resources required by this function invocation. | + +## Extend Footprint TTL :::info @@ -693,12 +712,29 @@ Soroban is currently live on Testnet, so this operation is only usable on Testne ::: -Bump the expiration ledger of entries for Soroban smart contracts with the `BumpFootprintExpirationOp`. +Extend the time to live (TTL) of entries for Soroban smart contracts with the `ExtendFootprintTTLOp`. This operation extends the TTL of the entries specified in the `readOnly` footprint of the transaction so that they will live at least until the `extendTo` ledger sequence number is reached. Note that Soroban transactions can only contain one operation per transaction. Learn more in the [Soroban docs](https://soroban.stellar.org/docs/fundamentals-and-concepts/state-expiration#bumpfootprintexpirationop). +**Threshold**: Medium +**Result**: `ExtendFootprintTTLResult` +**Parameters**: + +| Parameters | Type | Description | +| --- | --- | --- | +| Ext | ExtensionPoint | Reserved for later use. | +| Extend To | integer | The ledger sequence number the entries will live until. | + +**Possible errors**: + +| Error | Code | Description | +| --- | --- | --- | +| EXTEND_FOOTPRINT_TTL_MALFORMED | -1 | One or more of the inputs to the operation was malformed. | +| EXTEND_FOOTPRINT_TTL_RESOURCE_LIMIT_EXCEEDED | -2 | The TTL extension could not be completed within the currently configured resource constraints of the network. | +| EXTEND_FOOTPRINT_TTL_INSUFFICIENT_REFUNDABLE_FEE | -3 | The refundable Soroban fee provided was not sufficient to pay for TTL extension of the specified ledger entries. | + ## Restore Footprint :::info @@ -707,8 +743,24 @@ Soroban is currently live on Testnet, so this operation is only usable on Testne ::: -Make expired Soroban smart contract entries accessible again by restoring them with `RestoreFootprintOp`. +Make archived Soroban smart contract entries accessible again by restoring them with `RestoreFootprintOp`. This operation restores the archived entries specified in the `readWrite` footprint. Note that Soroban transactions can only contain one operation per transaction. Learn more in the [Soroban docs](https://soroban.stellar.org/docs/fundamentals-and-concepts/state-expiration#restorefootprintop). + +**Threshold**: Medium +**Result**: `RestoreFootprintResult` +**Parameters**: + +| Parameters | Type | Description | +| ---------- | -------------- | ----------------------- | +| Ext | ExtensionPoint | Reserved for later use. | + +**Possible errors**: + +| Error | Code | Description | +| --- | --- | --- | +| RESTORE_FOOTPRINT_MALFORMED | -1 | One or more of the inputs to the operation was malformed. | +| RESTORE_FOOTPRINT_RESOURCE_LIMIT_EXCEEDED | -2 | The archive restoration could not be completed within the currently configured resource constraints of the network. | +| RESTORE_FOOTPRINT_INSUFFICIENT_REFUNDABLE_FEE | -3 | The refundable Soroban fee provided was not sufficient to pay for archive restoration of the specified ledger entries. | diff --git a/docs/fundamentals-and-concepts/lumens.mdx b/docs/fundamentals-and-concepts/lumens.mdx index eca11d1c7..c75060b3a 100644 --- a/docs/fundamentals-and-concepts/lumens.mdx +++ b/docs/fundamentals-and-concepts/lumens.mdx @@ -3,7 +3,7 @@ title: Lumens (XLM) sidebar_position: 60 --- -Lumens (XLM) are the native currency of the Stellar network. The lumen is the only token that doesn’t require an issuer or trustline, and it pays all transaction fees and covers minimum balances on the network. +Lumens (XLM) are the native currency of the Stellar network. The lumen is the only token that doesn’t require an issuer or trustline, and it is used to pay all transaction fees and rent, and to cover minimum balance requirements on the network. To read up on the basics of lumens, head over to our Stellar Learn site: [Stellar Learn: Lumens](https://www.stellar.org/lumens) @@ -11,7 +11,9 @@ To read up on the basics of lumens, head over to our Stellar Learn site: [Stella Stellar requires a small fee for all transactions to prevent ledger spam and prioritize transactions during surge pricing. Transaction fees are paid in lumens. -To learn about fees on Stellar, see our [Fees, Surge Pricing, and Fee Strategies Encyclopedia Entry](../encyclopedia/fees-surge-pricing-fee-strategies) +To learn about fees on Stellar, see our [Fees, Surge Pricing, and Fee Strategies Encyclopedia Entry](../encyclopedia/fees-surge-pricing-fee-strategies). + +Smart contract transactions on Stellar employ a different fee structure based on an inclusion fee and resource consumption (which includes [rent](#rent)). Read more in the [Fees and Metering section](https://soroban.stellar.org/docs/fundamentals-and-concepts/fees-and-metering) in the Soroban docs. ## Base reserves @@ -30,3 +32,7 @@ For example, an account with one trustline, two offers, and a claimable balance 2 base reserves (1 XLM) + 3 subentries/base reserves (1.5 XLM) + 1 ledger entry/base reserve (1 XLM) = 3.5 XLM When you close a subentry, the associated base reserve will be added to your available balance. An account must always pay its own minimum balance unless a subentry is being sponsored by another account. For information about this, see our [Sponsored Reserves Encyclopedia Entry](../encyclopedia/sponsored-reserves). + +## Rent + +Smart contract data does not require any base reserves in order to live on the ledger, so every smart contract entry must pay rent instead. The rent charged for an entry to exist on the ledger is based on how big the entry is and how long the it should be live on the ledger before being archived. There are different rent requirements for each storage type `Persistent`, `Temporary`, and `Instance`, which you can read about in the [Fees and Metering section](https://soroban.stellar.org/docs/fundamentals-and-concepts/fees-and-metering#refundable-resources) of the Soroban docs. diff --git a/docs/fundamentals-and-concepts/networks.mdx b/docs/fundamentals-and-concepts/networks.mdx new file mode 100644 index 000000000..f68d0830f --- /dev/null +++ b/docs/fundamentals-and-concepts/networks.mdx @@ -0,0 +1,103 @@ +--- +title: Networks +sidebar_position: 30 +--- + +Stellar has three networks: the public network (Mainnet, also called Pubnet or the Public Network), the test network (Testnet), and a dev network (Futurenet). Mainnet is the main network used by applications in production. It connects to real financial rails and requires XLM to cover minimum balances, transaction fees, and rent. The Testnet is a smaller, free-to-use network maintained by SDF that functions like the Mainnet but doesn’t connect to real money. It has a built-in testnet XLM faucet (called Friendbot), and it resets on a regular cadence, so it's the best place for developers to test applications when they need a stable environment that mirrors Mainnet functionality. Futurenet is a dev network you can use to test more bleeding edge features that also has access to its own Friendbot. It resets whenever a reset is necessary, so it's not as predictable as Testnet, but it is where new features may be introduced before the are implemented in stable releases. + +## Stats: Mainnet versus Testnet versus Futurenet + +### Mainnet + +- Validator nodes are run by the public +- SDF offers a free [Horizon instance](https://horizon.stellar.org/) to interact with the Mainnet with a limited set of history, or you can [run your own](https://developers.stellar.org/docs/run-api-server) or use an instance offered by an infrastructure provider. +- You need to fund your account with XLM from another account +- Mainnet is limited to 1,000 operations per ledger and will be limited to a maximum of 30 smart contract transactions per ledger (the precise amount of smart contract txs per ledger can vary greatly depending on transaction [resource limits](https://soroban.stellar.org/docs/fundamentals-and-concepts/fees-and-metering#resource-limits)) + - See more detailed smart contract network settings in the section on [Fees and Metering](https://soroban.stellar.org/docs/fundamentals-and-concepts/fees-and-metering) in the Soroban docs +- No publicly available RPC, see RPC service providers [here](https://soroban.stellar.org/docs/reference/rpc-list) + +### Testnet + +- SDF runs three core validator nodes +- SDF offers a free [Horizon instance](https://horizon-testnet.stellar.org/) you can use to interact with the Testnet +- Friendbot is a faucet you can use for free Testnet XLM +- Testnet is limited to 100 operations per ledger and one smart contract transaction per ledger +- SDF offers free RPC endpoints, more information [here](https://soroban.stellar.org/docs/reference/rpc-list#sdf-futurenet-and-testnet-only) + +### Futurenet + +- SDF runs core validator nodes +- SDF offers a free [Horizon instance](https://horizon-futurenet.stellar.org) you can use to interact with the Futurenet +- Friendbot is a faucet you can use for free Futurenet XLM +- Futurenet is limited to 100 operations per ledger and one smart contract transaction per ledger +- SDF offers free RPC endpoints, more information [here](https://soroban.stellar.org/docs/reference/rpc-list#sdf-futurenet-and-testnet-only) + +## Friendbot + +Friendbot is a bot that funds accounts with fake XLM on Testnet or Futurenet. You can request XLM from Friendbot using the Stellar Laboratory or with various SDKs. Requests to Friendbot are rate limited, so use it wisely. Friendbot provides 10,000 fake XLM when funding a new account. + +If you are creating multiple accounts, you can fund your first account with Friendbot and then use that first account to fund your subsequent accounts using the Create Account operation. + +## Testnet and Futurenet data reset + +Testnet and Futurenet are reset periodically to the genesis ledger to declutter the network, remove spam, reduce the time needed to catch up on the latest ledger, and help maintain the system. Resets clear all ledger entries (accounts, trustlines, offers, smart contract data, etc.), transactions, and historical data from Stellar Core, Horizon, and the Soroban RPC- which is why developers should not rely on the persistence of accounts or the state of any balances when using Testnet or Futurenet. + +Futurenet resets are on a less regular cadence than Testnet resets and don't have a set schedule. + +Testnet resets happen once per quarter at 17:00 UTC and are announced at least two weeks in advance on the [Stellar Dashboard](http://dashboard.stellar.org/) and through several developer community channels. Here are the 2023 dates: + +March 15, 2023 +June 14, 2023 +~~September 13, 2023~~ Note: this reset was skipped due to its proximity to the Protocol 20 Testnet upgrade. +December 18, 2023 + +If you run a Testnet or Futurenet Horizon instance, you need to re-join and re-sync to the network after a reset. Check out how to do that here: [Testnet Reset](https://github.com/stellar/packages/blob/master/docs/testnet-reset.md). + +## Test data automation + +It is recommended that you have testing infrastructure that can repopulate the Testnet and Futurenet with useful data after a reset. This will make testing more reliable and will help you scale your testing infrastructure to a private network if you choose to do so. For example, you may want to: + +- Generate issuers of assets for testing the development of a wallet; +- Generate orders on the order book (both current and historical) for testing the development of a trading client; +- Recreate liquidity pools; +- Redeploy smart contracts. + +If you maintain an application, you should think about creating a data set that is representative enough to test your primary use cases, and allow for robust testing even when Testnet or Futurenet are not available. + +A script can automate this entire process by creating an account with Friendbot and submitting a set of transactions that are predefined as a part of your testing infrastructure. + +## What Testnet and Futurenet should and should not be used for + +### Testnet and Futurenet are good for + +- Creating test accounts (with funding from Friendbot); +- Developing applications and contracts and exploring tutorials on Stellar without the potential to lose any assets; +- Testing existing applications against new releases or release candidates of Stellar Core, Horizon, and the Soroban RPC; +- Performing data analysis on a smaller, non-trivial data set compared to the Mainnet. + +### Testnet and Futurenet are bad for + +- Load and stress testing; +- High availability test infrastructure- SDF does not guarantee Testnet availability; +- Long-term storage of data on the network since the network resets periodically; +- A testing infrastructure that requires more control over the test environment, such as: + - The ability to control the data reset frequency; + - The need to secure private or sensitive data (before launching on the Mainnet). You can always run your own test network for use cases that don’t work well with SDF’s Testnet. + +## Moving your project from Testnet or Futurenet to production + +Mainnet, Testnet, and Futurenet each have their own unique passphrase, which is used to validate signatures on a given transaction. + +The current passphrases for the Stellar Mainnet, Testnet, and Futurenet are: + +**Mainnet (Pubnet)**: `Public Global Stellar Network ; September 2015` + +**Testnet**: `Test SDF Network ; September 2015` + +**Futurenet**: `Test SDF Future Network ; October 2022` + +For applications that don’t rely on the state of the network (such as specific accounts needing to exist), you move to production by changing the network passphrase and ensuring your Horizon instance is connected to Mainnet. + +If you’ve been running a Stellar Core or Horizon instance against the Testnet and want to switch to production, changing the passphrase will require both respective databases to be completely reinitialized. If you run your own RPC on Testnet or Futurenet, you may want to use an RPC service when you move to Mainnet. Check out the RPC service providers [here](https://soroban.stellar.org/docs/reference/rpc-list). + +To learn more about network passphrases, see our [Network Passphrase Encyclopedia Entry](../encyclopedia/network-passphrases) diff --git a/docs/fundamentals-and-concepts/stellar-data-structures/accounts.mdx b/docs/fundamentals-and-concepts/stellar-data-structures/accounts.mdx index 981d6f623..fd8530968 100644 --- a/docs/fundamentals-and-concepts/stellar-data-structures/accounts.mdx +++ b/docs/fundamentals-and-concepts/stellar-data-structures/accounts.mdx @@ -36,7 +36,7 @@ Account data is stored in subentries, each of which increases an account’s min - Trustlines (includes traditional assets and pool shares) - Offers - Additional signers -- Data entries +- Data entries (includes data made with the `manageData` operation, not smart contract ledger entries) ## Trustlines diff --git a/docs/fundamentals-and-concepts/stellar-data-structures/assets.mdx b/docs/fundamentals-and-concepts/stellar-data-structures/assets.mdx index 22d5fc31a..0247d495b 100644 --- a/docs/fundamentals-and-concepts/stellar-data-structures/assets.mdx +++ b/docs/fundamentals-and-concepts/stellar-data-structures/assets.mdx @@ -9,6 +9,8 @@ Accounts on the Stellar network can be used to track, hold, and transfer any typ Assets on Stellar have two identifying characteristics: the asset code and the issuer. Since more than one organization can issue a credit representing the same asset, asset codes often overlap (for example, multiple companies offer a USD token on Stellar). Assets are uniquely identified by the combination of their asset code and issuer. +You can also create smart contract tokens using the [Token Interface](https://soroban.stellar.org/docs/reference/interfaces/token-interface) but it is possible, and even recommended in most cases, to [wrap a Stellar asset](#wrapping-stellar-assets) using the Stellar Asset Contract for use in smart contracts. + ## Asset components ### Asset code @@ -25,6 +27,12 @@ There is no dedicated operation to create an asset on Stellar. Instead, assets a The public key of the issuing account is linked on the ledger to the asset. Responsibility for and control over an asset resides with the issuing account. Since settings are stored at the account level on the ledger, the issuing account is where you use set_options operations to link to meta-information about an asset and set authorization flags. +## Wrapping Stellar assets + +Assets issued on the Stellar network can be used in smart contracts with the Stellar Asset Contract (SAC), which is an implementation of [CAP-46-6: Smart Contract Standardized Asset](https://github.com/stellar/stellar-protocol/blob/master/core/cap-0046-06.md). The SAC allows users to use their Stellar account and trustline balances in Soroban and is a primary intersection where smart contracts interact with the rest of the Stellar network. + +Learn more in the [SAC section in the Soroban docs](https://soroban.stellar.org/docs/advanced-tutorials/stellar-asset-contract). + ## Representation In Horizon, assets are represented in a JSON object: diff --git a/docs/fundamentals-and-concepts/stellar-data-structures/contracts.mdx b/docs/fundamentals-and-concepts/stellar-data-structures/contracts.mdx new file mode 100644 index 000000000..3087511da --- /dev/null +++ b/docs/fundamentals-and-concepts/stellar-data-structures/contracts.mdx @@ -0,0 +1,58 @@ +--- +title: Smart Contracts +sidebar_position: 50 +--- + +:::note + +Stellar has integrated a smart contracts platform called "[Soroban](https://soroban.stellar.org/docs)" into the core protocol. This platform has now reached a stable release, and will be available on the Stellar network as of protocol v20. + +::: + +A smart contract is a programmed set of executable code and state that can be invoked or used on the Stellar network. + +## Wasm Bytecode + +Once a smart contract has been written by a developer and compiled into a WebAssembly (Wasm) executable file, it can then be "installed" onto the Stellar network. A `CONTRACT_DATA` [ledger entry](ledgers.mdx) is created to store this binary data and its unique identifier is the hash of the executable file. This binary executable is stored independently from its deployed contract(s). When a Stellar transaction attempts to invoke a contract function, the Wasm bytecode is first retrieved from the ledger and a secure, isolated runtime virtual machine ("VM") is instantiated so it can run the bytecode for the contract and then exit. + +## Contract Instances + +After the executable bytecode is installed on-chain, contract instances can be deployed which reference the aformentioned bytecode. A smart contract executable can have a one-to-many relationship with "contract instances" which function independently. This means the same executable code can be used by multiple contract instances that all behave identically (because of the shared executable code), while maintaining separate and distinct state data (because the data is tied to the contract instance). A contract instance is stored as its own ledger entry, and any of the contract's [instance storage](#instance-storage) is stored in that same ledger entry alongside the contract instance. + +```mermaid +flowchart LR + A[my instance] & B[your instance]--> C[contract Wasm] +``` + +## Contract Storage + +In addition to the ledger entries that are created during the contract install/deploy process, each contract can create and access its own set of ledger entries. These ledger entries (as well as the contract code and the contract instance ledger entries) are subject to [state archival](https://soroban.stellar.org/docs/fundamentals-and-concepts/state-archival) lifetimes (a ledger entry's "TTL ledger"). While they all function similarly, each type has its own fee and TTL behavior. + +### Temporary Storage + +- Cheapest fees. +- Permanently deleted when its TTL ledger is reached, cannot be restored. +- Suitable for time-bounded data (i.e. price oracles, signatures, etc.) and easily recreateable data. +- Unlimited amount of storage. + +### Persistent Storage + +- Most expensive fees (same price as `Instance` storage). +- Recoverable after archival, can be restored using the [`RestoreFootprintOp`](../list-of-operations.mdx#restore-footprint) operation. +- Does not share the same lifetime as the contract instance. If the contract instance has not reached its TTL ledger, `Persistent` data may still be archived and need to be restored before invoking the contract. +- Unlimited amount of storage. +- Suitable for user data that cannot be `Temporary` (i.e. balances). + +### Instance Storage + +:::info + +While we are making a distinction here between "persistent" and "instance" storage, instance storage is really just a convenient, abstracted type of persistent storage. Under the hood, the instance storage works the same as persistent storage, except its own TTL is tied to that of the contract instance. + +::: + +- Most expensive fees (same price as `Persistent` storage). +- Recoverable after archival, can be restored using the [`extendFootprintTTLOp`](../list-of-operations.mdx#extend-footprint-ttl) operation. +- Shares the same lifetime as the contract instance. If the contract instance has not reached its TTL ledger, instance data is guaranteed to be accessible. +- Limited amount of storage available. +- Suitable for "shared" contract state that cannot be `Temporary` (i.e. admin accounts, contract metadata, etc.). diff --git a/docs/fundamentals-and-concepts/stellar-data-structures/ledgers.mdx b/docs/fundamentals-and-concepts/stellar-data-structures/ledgers.mdx index 9f10b76b5..b6c796895 100644 --- a/docs/fundamentals-and-concepts/stellar-data-structures/ledgers.mdx +++ b/docs/fundamentals-and-concepts/stellar-data-structures/ledgers.mdx @@ -3,7 +3,7 @@ title: Ledgers sidebar_position: 10 --- -A ledger represents the state of the Stellar network at a point in time. It is shared across all Core nodes in the network and contains the list of accounts and balances, orders on the distributed exchange, and any other persisting data. +A ledger represents the state of the Stellar network at a point in time. It is shared across all Core nodes in the network and contains the list of accounts and balances, orders on the distributed exchange, smart contract data, and any other persisting data. Other blockchains refer to this concept as a "block", and the entire blockchain as "the ledger". diff --git a/docs/fundamentals-and-concepts/stellar-data-structures/operations-and-transactions.mdx b/docs/fundamentals-and-concepts/stellar-data-structures/operations-and-transactions.mdx index a8d599bf1..f073cace7 100644 --- a/docs/fundamentals-and-concepts/stellar-data-structures/operations-and-transactions.mdx +++ b/docs/fundamentals-and-concepts/stellar-data-structures/operations-and-transactions.mdx @@ -5,17 +5,17 @@ sidebar_position: 40 ## Operations and transactions: how they work -To perform actions with an account on the Stellar network, you compose operations, bundle them into a transaction, and then sign and submit the transaction to the network. +To perform actions with an account on the Stellar network, you compose operations, bundle them into a transaction, and then sign and submit the transaction to the network. Smart contract transactions (those with `InvokeHostFunctionOp`, `ExtendFootprintTTLOp`, or `RestoreFootprintOp` operations) can only have one operation per transaction. ### Operations -Operations are individual commands that modify the ledger. Operations are used to send payments, enter orders into the decentralized exchange, change settings on accounts, and authorize accounts to hold assets. +Operations are individual commands that modify the ledger. Operations are used to send payments, invoke a smart contract function, enter orders into the decentralized exchange, change settings on accounts, and authorize accounts to hold assets. All operations fall into one of three threshold categories: low, medium, or high, and each threshold category has a weight between 0 and 255 (which can be determined using set_options). Thresholds determine what signature weight is required for the operation to be accepted. For example, let’s say an account sets the medium threshold weight to 5. If the account wants to successfully establish a trustline with the `changeTrust` operation, the weight of the signature(s) must be greater than or equal to 5. -To learn more about signature weight, see the [Signature and Multisignature Encyclopedia Entry](../../encyclopedia/signatures-multisig) +To learn more about signature weight, see the [Signature and Multisignature Encyclopedia Entry](../../encyclopedia/signatures-multisig). -View a comprehensive list of Stellar operations and their threshold levels in the [List of Operations section](../list-of-operations) +View a comprehensive list of Stellar operations and their threshold levels in the [List of Operations section](../list-of-operations). ### Transactions @@ -23,7 +23,7 @@ The Stellar network encodes transactions using a standardized protocol called Ex Accounts can only perform one transaction at a time. -Transactions comprise a bundle of between 1-100 operations and are signed and submitted to the ledger by accounts. Transactions always need to be authorized by the source account’s public key to be valid, which involves signing the transaction object with the public key’s associated secret key. A transaction plus its signature(s) is called a transaction envelope. +Transactions comprise a bundle of between 1-100 operations (except smart contract transactions, which can only have one operation per transaction) and are signed and submitted to the ledger by accounts. Transactions always need to be authorized by the source account’s public key to be valid, which involves signing the transaction object with the public key’s associated secret key. A transaction plus its signature(s) is called a transaction envelope. A transaction may need more than one signature- this happens if it has operations that affect more than one account or if it has a high threshold weight. Check out the [Signature and Multisignature Encyclopedia Entry](../../encyclopedia/signatures-multisig) for more information. @@ -31,6 +31,8 @@ Transactions are atomic. Meaning if one operation in a transaction fails, all op Operations are executed for the source account of the transaction unless an operation override is defined. +Smart contract transactions also go through a simulation process where developers can test how the transaction would be executed on the network using the RPC endpoint `simulateTransaction`. Read more in the [Soroban docs](https://soroban.stellar.org/docs/fundamentals-and-concepts/interacting-with-contracts#transaction-simulation). + #### Transaction attributes - [Fee](../../encyclopedia/fees-surge-pricing-fee-strategies) @@ -148,53 +150,3 @@ Each operation must pass all the validity checks for an operation, described in #### Memo (if applicable) The memo type must be a valid type, and the memo itself must adhere to the formatting of the memo type. - -## Transaction lifecycle - -### 1. Creation (Transaction Creator) - -A user creates a transaction by setting the source account, sequence number, list of operations and their respective parameters, fee or fee-bump, and optionally a memo and/or preconditions. - -### 2. Signing (Transaction Signers) - -Once the transaction is complete, it becomes a transaction envelope containing the transaction itself and a list of signers. All the required signatures must be collected and added to the transaction envelope’s list of signers. Commonly, it’s just the signature of the account doing the transaction, but more complicated setups can require collecting signatures from multiple parties. - -### 3. Submitting (Transaction Submitter) - -After signing, the transaction can now be submitted to the Stellar network. If the transaction is invalid, it will be rejected immediately by Stellar Core, the account’s sequence number will not be incremented, and no fee will be consumed from the source account. Multiple transactions for the same account can be submitted, provided each sequence number is off by one (unless minimum sequence number preconditions are set). If they are all valid, Stellar Core will craft a transaction set with each of those transactions applied in sequence number order. Transactions are typically submitted using Horizon, but you can also submit the transaction directly to an instance of Stellar Core. - -### 4. Propagating (Validator) - -Once Stellar Core has determined that a transaction is valid, it will propagate the transaction to all other servers to which it’s connected. This way, a valid transaction is flooded to the entire Stellar network. - -### 5. Crafting a candidate transaction set (Validator) - -When it’s time to close the ledger, each Stellar Core validator takes all valid transactions it is aware of since the last ledger close and collects them into a candidate transaction set. If it hears about any incoming transactions now, it puts them aside for the next ledger close. If the number of operations in the candidate transaction set is greater than the maximum number of operations per ledger, transactions will be prioritized by their fee for inclusion in the set. - -### 6. Nominating a transaction set (Validator) - -Once each validator has crafted a candidate transaction set, the set is nominated to the network. - -### 7. Stellar Consensus Protocol (SCP) determines the final transaction set (Validator Network) - -SCP resolves any differences between candidate transaction sets and ultimately determines a single transaction set to apply, the close time of the ledger, and any upgrades to the protocol that need to be applied network-wide at the apply time. - -If a transaction doesn’t make it into the transaction set, it is kept around in memory to be added to the next transaction set on a best-effort basis. - -If a transaction is kept in memory after a certain number of ledger closes, it will be banned for several additional ledgers. This means no attempt will be made to include it in a candidate transaction set additional ledgers during this time. - -### 8. Transaction apply order is determined (Validator Network) - -Once SCP agrees on a particular transaction set, the apply order is computed for the transaction set. This shuffles the set's order to create uncertainty for competing transactions and maintains the order of sequence numbers for multiple transactions per account. - -### 9. Fees are collected (Validator) - -Fees are collected for all transactions simultaneously. - -### 10. Application (Validator) - -Each transaction is applied in the previously-determined order. For each transaction, the account’s sequence number is consumed (increased by 1), the transaction’s validity is rechecked, and each operation is applied in the order they occur in the transaction. Operations may fail at this stage due to errors that can occur outside of the transaction and operation validity checks. For example, an insufficient balance for a payment is not checked at submission and would fail at this time. The entire transaction will fail if any operation fails, and all previous operations will be rolled back. - -### 11. Protocol Upgrades (Validator) - -Finally, upgrades are run if an upgrade took place. This can include arbitrary logic to upgrade the ledger state for protocol upgrades, along with ledger header modifications, including the protocol version, base fee, maximum number of operations per ledger, etc. Once this has been completed, the life cycle begins anew. diff --git a/docs/fundamentals-and-concepts/stellar-stack.mdx b/docs/fundamentals-and-concepts/stellar-stack.mdx index 79b9b07b1..2b56fd5a9 100644 --- a/docs/fundamentals-and-concepts/stellar-stack.mdx +++ b/docs/fundamentals-and-concepts/stellar-stack.mdx @@ -3,9 +3,9 @@ title: Stellar Stack sidebar_position: 20 --- -The Stellar stack is made up of four software components (Stellar Core, Horizon API, SDKs, and the testnet & pubnet), each of which plays a specific part in providing financial infrastructure that is resilient to failures, available to anyone, and fast and cheap enough to serve real-world use cases. +The Stellar stack is made up of the following components: Stellar Core, Horizon API, RPC, CLI, SDKs, DeFi protocols, and the [networks](./networks), each of which plays a specific part in providing financial infrastructure that is resilient to failures, available to anyone, and fast and cheap enough to serve real-world use cases. -![Stellar Stack Diagram](/assets/stellar-stack.png) +![Stellar Stack](/assets/updated-stellar-stack.png) ## Stellar Core @@ -13,18 +13,41 @@ Stellar Core is the program used by the individual nodes (or computers) that mak Nodes reach consensus using the Stellar Consensus Protocol, which can you can learn more about here: [Stellar Consensus Protocol](./stellar-consensus-protocol) -Anyone can run a Stellar Core node, but you don’t have to in order to build on Stellar. We recommend you do so if you issue an asset and want to ensure the accuracy of the ledger and/or if you want to contribute to Stellar’s overall health and decentralization. Check out our tutorial on installing, configuring, and maintaining your own node here: [Run a Core Node Tutorial](../run-core-node) +Anyone can run a Stellar Core node, but you don’t have to in order to build on Stellar. We recommend you do so if you issue an asset and want to ensure the accuracy of the ledger, if you want to participate in network governance by voting on protocol version, minimum fees, and resource and ledger limits, and/or if you want to contribute to Stellar’s overall health and decentralization. Check out our tutorial on installing, configuring, and maintaining your own node here: [Run a Core Node Tutorial](../run-core-node). ## Horizon API Horizon is the client-facing RESTful HTTP API server that allows programmatic access to submit transactions and query the network’s historical data. It acts as the interface for applications that want to access the Stellar network. You can communicate with Horizon using an SDK, a web browser, or with simple command tools like cURL. -You do not need to run your own Horizon instance — when you're getting started, you can use the free SDF Horizon instance to access the network — but it is recommended that you do when you’re ready to launch a finished product. Check out how to do so here: [Run an API Server Tutorial](../run-api-server) +You do not need to run your own Horizon instance — when you're getting started, you can use the free SDF Horizon instance to access the network — but it is recommended that you do when you’re ready to launch a finished product. Check out how to do so here: [Run an API Server Tutorial](../run-api-server). Learn all there is to know about using Horizon in the Horizon [API Reference documentation](https://developers.stellar.org/api). +## RPC + +Soroban's RPC is a JSON RPC server that provides an interface for users and applications to interact with smart contracts on the Stellar blockchain. When an application would like to interact with smart contracts, it sends a request to the RPC server. The server interprets these requests, translates them into a format understandable by the blockchain nodes, and forwards them. After processing the requests, the blockchain nodes send back the results. The RPC server receives these results and sends them back to the requesting application. + +SDF has RPC endpoints available for Futurenet and Testnet. These services are free to use, and are suitable for development and testing. + +SDF does not provide a publicly available RPC endpoint for Mainnet. Developers should [select an ecosystem provider](https://soroban.stellar.org/docs/reference/rpc-list) that works for their project before migrating to Mainnet. In some cases, projects may choose to run their own RPC instance. + +## CLI + +The Soroban CLI is the command line interface to Soroban and can be downloaded [here](https://soroban.stellar.org/docs/getting-started/setup#install-the-soroban-cli). The CLI allows developers to build, deploy, and interact with smart contracts on the Stellar blockchain, generate keypairs, manage networks, and more. When a user inputs a command into the CLI, the CLI software translates this command into an appropriate RPC request following the JSON RPC protocol. + ## SDKs -SDKs simplify some of the work of accessing Horizon by converting the data into friendlier formats and allowing you to program in the language of your choice. Stellar’s SDKs show you how to request data and create and submit transactions. +SDKs simplify some of the work of accessing Horizon and the Soroban RPC by converting the data into friendlier formats and allowing you to program in the language of your choice. Stellar’s SDKs show you how to request data and create and submit transactions. Soroban's SDKs allow you to write smart contracts in Rust and interact with smart contracts in a myriad of other languages. + +View Stellar's [SDK library](../tools-and-sdks#sdk-library) to access our SDKs and their documentation. +View Soroban's [SDK library](https://soroban.stellar.org/docs/category/sdks) in the Soroban docs. + +## DeFi protocols + +DeFi protocols are financial frameworks (such as lending and borrowing tools, AMMs, and decentralized exchanges) that are designed to operate without the need for traditional financial intermediaries. Other applications can interoperate with and leverage various DeFi protocols on the network for their own operations. + +## Networks + +Stellar has three networks: the public network (Mainnet, also called Pubnet or the Public Network), the test network (Testnet), and a dev network (Futurenet). Mainnet is the main network used by applications in production. The Testnet is a smaller, free-to-use network maintained by SDF that functions like the Mainnet but doesn’t connect to real money and is the best place for developers to test their applications. Futurenet is a dev network you can use to test more bleeding edge features. -Check out our [SDK library](../tools-and-sdks#sdk-library) to access our SDKs and their documentation. +Read more about the different networks in the [Networks section](./networks). diff --git a/docs/fundamentals-and-concepts/testnet-and-pubnet.mdx b/docs/fundamentals-and-concepts/testnet-and-pubnet.mdx deleted file mode 100644 index ebb988730..000000000 --- a/docs/fundamentals-and-concepts/testnet-and-pubnet.mdx +++ /dev/null @@ -1,87 +0,0 @@ ---- -title: Testnet and Pubnet -sidebar_position: 30 ---- - -Stellar has two networks: the public network (Pubnet, also called Mainnet) and the test network (Testnet). The Pubnet is the main network used by applications in production. It connects to real rails and requires XLM to cover minimum balances and transaction fees. The Testnet is a smaller, free-to-use network maintained by SDF that functions like the Pubnet but doesn’t connect to real money. It has a built-in testnet XLM faucet, and it's the best place for developers to test their applications. - -## Stats: Testnet versus Pubnet - -### Testnet - -- SDF runs three core validator nodes -- SDF offers a free [Horizon instance](https://horizon-testnet.stellar.org/) you can use to interact with the Testnet -- Friendbot is a faucet you can use for free Testnet XLM -- Testnet is limited to 100 operations per ledger - -### Pubnet - -- Validator nodes are run by the public -- SDF offers a free [Horizon instance](https://horizon.stellar.org/) to interact with the Pubnet, or you can run your own -- You need to fund your account with XLM from another account -- Pubnet is limited to 1,000 operations per ledger - -## Friendbot - -Friendbot is a bot that funds accounts with fake XLM on Testnet. You can request XLM from friendbot using the Stellar Laboratory or with various SDKs. Requests to friendbot are rate limited, so use it wisely. Friendbot provides 10,000 fake XLM when funding a new Testnet account. - -If you are creating multiple Testnet accounts, fund your first account with friendbot and then use that first account to fund your subsequent accounts using the Create Account operation. - -## Testnet data reset - -The Testnet is reset periodically to the genesis ledger to declutter the network, remove spam, reduce the time needed to catch up on the latest ledger, and help maintain the system. Resets clear all ledger entries (accounts, trustlines, offers, etc.), transactions, and historical data from Stellar Core and Horizon- which is why developers should not rely on the persistence of accounts or the state of any balances when using Testnet. - -Testnet resets happen once per quarter at 17:00 UTC and are announced at least two weeks in advance on the [Stellar Dashboard](http://dashboard.stellar.org/) and through several developer community channels. Here are the 2023 dates: - -March 15, 2023 -June 14, 2023 -~~September 13, 2023~~ Note: this reset was skipped due to its proximity to the Protocol 20 Testnet upgrade. -December 18, 2023 - -If you run a Testnet Horizon instance, you need to re-join and re-sync to the network after a reset. Check out how to do that here: [Testnet Reset](https://github.com/stellar/packages/blob/master/docs/testnet-reset.md). - -## Test data automation - -It is recommended that you have testing infrastructure that can repopulate the Testnet with useful data after a reset. This will make testing more reliable and will help you scale your testing infrastructure to a private network if you choose to do so. For example, you may want to: - -- Generate issuers of assets for testing the development of a wallet -- Generate orders on the order book (both current and historical) for testing the development of a trading client -- Recreate liquidity pools - -If you maintain an application, you should think about creating a data set that is representative enough to test your primary use cases, and allow for robust testing even when Testnet is not available. - -A script can automate this entire process by creating an account with friendbot and submitting a set of transactions that are predefined as a part of your testing infrastructure. - -## What Testnet should and should not be used for - -### Testnet is good for - -- Creating test accounts (with funding from friendbot) -- Developing applications and exploring tutorials on Stellar without the potential to lose any assets -- Testing existing applications against new releases or release candidates of Stellar Core and Horizon -- Performing data analysis on a smaller, non-trivial data set compared to the Pubnet - -### Testnet is bad for - -- Load and stress testing -- High availability test infrastructure- SDF does not guarantee Testnet availability -- Long-term storage of data on the network since the network resets periodically -- A testing infrastructure that requires more control over the test environment, such as: - - The ability to control the data reset frequency - - The need to secure private or sensitive data (before launching on the Pubnet) You can always run your own test network for use cases that don’t work well with SDF’s Testnet. - -## Moving your project from Testnet to production - -The Pubnet and Testnet each have their own unique passphrase, which is used to validate signatures on a given transaction. - -The current passphrases for the Stellar Pubnet and Testnet are: - -**Pubnet**: 'Public Global Stellar Network ; September 2015' - -**Testnet**: 'Test SDF Network ; September 2015' - -For applications that don’t rely on the state of the network (such as specific accounts needing to exist), you move to production by changing the network passphrase and ensuring your Horizon instance is connected to Pubnet. - -If you’ve been running a Stellar Core or Horizon instance against the Testnet and want to switch to production, changing the passphrase will require both respective databases to be completely reinitialized. - -To learn more about network passphrases, see our [Network Passphrase Encyclopedia Entry](../encyclopedia/network-passphrases) diff --git a/docs/fundamentals-and-concepts/transaction-lifecycle.mdx b/docs/fundamentals-and-concepts/transaction-lifecycle.mdx new file mode 100644 index 000000000..086aeb435 --- /dev/null +++ b/docs/fundamentals-and-concepts/transaction-lifecycle.mdx @@ -0,0 +1,58 @@ +--- +title: Transaction Lifecycle +sidebar_position: 65 +--- + +:::note + +This is the transaction lifecycle for a classic Stellar transaction. Adding smart contract components to this section is currently a work in progress. + +::: + +### 1. Creation (Transaction Creator) + +A user creates a transaction by setting the source account, sequence number, list of operations and their respective parameters, fee or fee-bump, and optionally a memo and/or preconditions. + +### 2. Signing (Transaction Signers) + +Once the transaction is complete, it becomes a transaction envelope containing the transaction itself and a list of signers. All the required signatures must be collected and added to the transaction envelope’s list of signers. Commonly, it’s just the signature of the account doing the transaction, but more complicated setups can require collecting signatures from multiple parties. + +### 3. Submitting (Transaction Submitter) + +After signing, the transaction can now be submitted to the Stellar network. If the transaction is invalid, it will be rejected immediately by Stellar Core, the account’s sequence number will not be incremented, and no fee will be consumed from the source account. Multiple transactions for the same account can be submitted, provided each sequence number is off by one (unless minimum sequence number preconditions are set). If they are all valid, Stellar Core will craft a transaction set with each of those transactions applied in sequence number order. Transactions are typically submitted using Horizon, but you can also submit the transaction directly to an instance of Stellar Core. + +### 4. Propagating (Validator) + +Once Stellar Core has determined that a transaction is valid, it will propagate the transaction to all other servers to which it’s connected. This way, a valid transaction is flooded to the entire Stellar network. + +### 5. Crafting a candidate transaction set (Validator) + +When it’s time to close the ledger, each Stellar Core validator takes all valid transactions it is aware of since the last ledger close and collects them into a candidate transaction set. If it hears about any incoming transactions now, it puts them aside for the next ledger close. If the number of operations in the candidate transaction set is greater than the maximum number of operations per ledger, transactions will be prioritized by their fee for inclusion in the set. + +### 6. Nominating a transaction set (Validator) + +Once each validator has crafted a candidate transaction set, the set is nominated to the network. + +### 7. Stellar Consensus Protocol (SCP) determines the final transaction set (Validator Network) + +SCP resolves any differences between candidate transaction sets and ultimately determines a single transaction set to apply, the close time of the ledger, and any upgrades to the protocol that need to be applied network-wide at the apply time. + +If a transaction doesn’t make it into the transaction set, it is kept around in memory to be added to the next transaction set on a best-effort basis. + +If a transaction is kept in memory after a certain number of ledger closes, it will be banned for several additional ledgers. This means no attempt will be made to include it in a candidate transaction set additional ledgers during this time. + +### 8. Transaction apply order is determined (Validator Network) + +Once SCP agrees on a particular transaction set, the apply order is computed for the transaction set. This shuffles the set's order to create uncertainty for competing transactions and maintains the order of sequence numbers for multiple transactions per account. + +### 9. Fees are collected (Validator) + +Fees are collected for all transactions simultaneously. + +### 10. Application (Validator) + +Each transaction is applied in the previously-determined order. For each transaction, the account’s sequence number is consumed (increased by 1), the transaction’s validity is rechecked, and each operation is applied in the order they occur in the transaction. Operations may fail at this stage due to errors that can occur outside of the transaction and operation validity checks. For example, an insufficient balance for a payment is not checked at submission and would fail at this time. The entire transaction will fail if any operation fails, and all previous operations will be rolled back. + +### 11. Protocol Upgrades (Validator) + +Finally, upgrades are run if an upgrade took place. This can include arbitrary logic to upgrade the ledger state for protocol upgrades, along with ledger header modifications, including the protocol version, base fee, maximum number of operations per ledger, etc. Once this has been completed, the life cycle begins anew. diff --git a/docs/glossary.mdx b/docs/glossary.mdx index 143b53a33..2d9890016 100644 --- a/docs/glossary.mdx +++ b/docs/glossary.mdx @@ -153,7 +153,7 @@ Learn more in our [Lumens section](./fundamentals-and-concepts/lumens#minimum-ba ### Network capacity -The maximum number of operations per ledger, as determined by validator vote. Currently 1,000 operations for the pubnet and 100 operations for the testnet. +The maximum number of operations per ledger, as determined by validator vote. Currently 1,000 operations for the mainnet and 100 operations for the testnet. ### Number of subentries @@ -187,7 +187,7 @@ An order that does not execute against a marketable counter order with the same ### Passphrase -The Pubnet and Testnet each have their own unique passphrase, which are used to validate signatures on a given transaction. +The Mainnet and Testnet each have their own unique passphrase, which are used to validate signatures on a given transaction. Learn more about network passphrases in the [Network Passphrases Encyclopedia Entry](./encyclopedia/network-passphrases). @@ -213,11 +213,11 @@ The ratio of the quote asset and the base asset in an order. The public part of a keypair that identifies a Stellar account. The public key is public- it is visible on the ledger, anyone can look it up, and it is used when sending payments to the account, identifying the issuer of an asset, and verifying that a transaction is authorized. -### Pubnet +### Mainnet or Pubnet The Stellar Public Network, aka mainnet, the main network used by applications in production. -Read more in our [Testnet & Pubnet section](./fundamentals-and-concepts/testnet-and-pubnet). +Read more in our [Networks section](./fundamentals-and-concepts/networks). ### Rate-limiting @@ -283,7 +283,7 @@ As cents are to dollars, stroops are to assets: the smallest unit of an asset, o The Stellar Test Network is maintained by the Stellar Development Foundation, which developers can use to test applications. Testnet is free to use and provides the same functionality as the main (public) network. -Read more in our [Testnet & Pubnet section](./fundamentals-and-concepts/testnet-and-pubnet). +Read more in our [Networks](./fundamentals-and-concepts/networks). ### Threshold diff --git a/docs/issuing-assets/how-to-issue-an-asset.mdx b/docs/issuing-assets/how-to-issue-an-asset.mdx index 73e4c298e..fb11020b0 100644 --- a/docs/issuing-assets/how-to-issue-an-asset.mdx +++ b/docs/issuing-assets/how-to-issue-an-asset.mdx @@ -14,7 +14,7 @@ You must ensure you have the required amount of XLM to create your issuing and d If you’d like to avoid your users having to deal with transaction fees, consider using fee-bump transactions. Read more in our [Fee-Bump Transaction Encyclopedia Entry](../encyclopedia/fee-bump-transactions). -Learn about the testnet and pubnet in our [Testnet and Pubnet section](../fundamentals-and-concepts/testnet-and-pubnet). +Learn about the testnet and mainnet in our [Networks section](../fundamentals-and-concepts/networks). Learn more about fees in our [Fees, Surge Pricing, and Fee Strategies section](../encyclopedia/fees-surge-pricing-fee-strategies). diff --git a/docs/run-core-node/configuring.mdx b/docs/run-core-node/configuring.mdx index b561d4119..0b7b59b47 100644 --- a/docs/run-core-node/configuring.mdx +++ b/docs/run-core-node/configuring.mdx @@ -53,7 +53,7 @@ This command initializes the database and bucket directories, and then exits. Yo ## Network Passphrase -Use the `NETWORK_PASSPHRASE` field to specify whether your node connects to the [testnet](../fundamentals-and-concepts/testnet-and-pubnet.mdx) or the public network. Your choices: +Use the `NETWORK_PASSPHRASE` field to specify whether your node connects to the [testnet](../fundamentals-and-concepts/networks.mdx) or the public network. Your choices: - `NETWORK_PASSPHRASE="Test SDF Network ; September 2015"` - `NETWORK_PASSPHRASE="Public Global Stellar Network ; September 2015"` diff --git a/docs/tutorials/create-account.mdx b/docs/tutorials/create-account.mdx index 94594d81f..9af6183b3 100644 --- a/docs/tutorials/create-account.mdx +++ b/docs/tutorials/create-account.mdx @@ -82,7 +82,7 @@ print(f"Public Key: {pair.public_key}") A valid keypair, however, does not make an account: in order to prevent unused accounts from bloating the ledger, Stellar requires accounts to hold a [minimum balance](../fundamentals-and-concepts/lumens.mdx#minimum-balance) of 1 XLM before they actually exist. Until it gets a bit of funding, your keypair doesn't warrant space on the ledger. -On the [public network](../fundamentals-and-concepts/testnet-and-pubnet.mdx), where live users make live transactions, your next step would be to acquire XLM, which you can do by consulting our [lumen buying guide](https://www.stellar.org/lumens/exchanges). Because this tutorial runs on the [test network](../fundamentals-and-concepts/testnet-and-pubnet.mdx), you can get 10,000 test XLM from Friendbot, which is a friendly account funding tool. +On the [public network](../fundamentals-and-concepts/networks.mdx), where live users make live transactions, your next step would be to acquire XLM, which you can do by consulting our [lumen buying guide](https://www.stellar.org/lumens/exchanges). Because this tutorial runs on the [test network](../fundamentals-and-concepts/networks.mdx), you can get 10,000 test XLM from Friendbot, which is a friendly account funding tool. To do that, send Friendbot the public key you created. It’ll create and fund a new account using that public key as the account ID. diff --git a/nginx/includes/redirects.conf b/nginx/includes/redirects.conf index 0bf0732c4..15f78bd13 100644 --- a/nginx/includes/redirects.conf +++ b/nginx/includes/redirects.conf @@ -28,6 +28,7 @@ rewrite ^/docs/start/stellar-stack$ "/docs/fundamentals-and-concepts/stellar-sta rewrite ^/docs/tutorials/handling-errors$ "/docs/encyclopedia/error-handling" permanent; rewrite ^/docs/tutorials/securing-projects$ "/docs/encyclopedia/securing-web-based-projects" permanent; rewrite ^/docs/tutorials/moneygram-access-integration-guide$ "/docs/building-apps/moneygram-access-integration-guide" permanent; +rewrite ^/docs/fundamentals-and-concepts/testnet-and-pubnet$ "/docs/fundamentals-and-concepts/networks" permanent; # moving /api/* locations to /api/horizon (leaving /api intact for the "overview page") rewrite ^/api(/(?!horizon|(anchor|stellar-disbursement)-platform).+)$ /api/horizon$1 permanent; # moving /ap_api locations to /api/anchor-platform diff --git a/static/assets/updated-stellar-stack.png b/static/assets/updated-stellar-stack.png new file mode 100644 index 0000000000000000000000000000000000000000..557ae4628aa0fb6ad6d58c0ca5c7594deb4707c1 GIT binary patch literal 25157 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