# Overview Xyxyx is building the world’s most robust infrastructure for tokenizing critical text records, unlocking new frontiers for multiple industries, from AI to finance to legal sectors. First time learning about Xyxyx? Go to the [Introduction](https://docs.xyxyx.pro/introduction) for a brief background on our vision. *** ### Developers For developers, please refer to our [Developer Documentation](https://developer.xyxyx.pro/). *** ### Questions and feedback If you have any questions or feedback, feel free to email us at . # Introduction
### Problem In today's digital age, the provenance and integrity of critical text records are often compromised. Traditional storage methods are vulnerable to tampering and loss, posing significant risks for industries that rely on trustworthy and immutable critical text records. This includes sectors such as finance, healthcare, legal, and AI, where the provenance and integrity of critical text records are paramount. *** ### Solution Xyxyx addresses these challenges through the [Xyxyx Text-Based Tokenization Architecture (XTBTA)](/xyxyx-text-based-tokenization-architecture-xtbta), which employs blockchain technology to bond critical text records to tokens — [Text-Based Tokens (TBTs)](/text-based-tokens-tbts). Through text-based tokenization, Xyxyx ensures that every critical text record is cryptographically immutable and permanently stored on Ethereum. By eliminating dependencies on off-chain hosting services (e.g., IPFS), Xyxyx provides a fully blockchain-based solution that guarantees the highest level of data provenance and integrity. *** ### Benefits Xyxyx's novel approach to tokenization holds immense potential for a wide array of industries. In the AI sector, it enables the auditable, transparent, and immutable recording of AI-generated content, enhancing accountability and trust. In finance, it facilitates the tokenization of RWAs and traditional financial instruments, improving transparency and efficiency. The legal industry benefits from the secure and permanent storage of critical documents, ensuring compliance and eliminating risks of tampering. *** ### Goals By materializing the world's most robust infrastructure stack for tokenizing critical text records, Xyxyx is dedicated to redefining data provenance and integrity standards across multiple industries, from AI to finance to legal. *** ### Vision Xyxyx envisions a future where the provenance and integrity of critical text records are universally guaranteed through the power of Ethereum and text-based tokens. At Xyxyx, we aim to set new standards for data provenance and integrity, enabling multiple industries to operate with unparalleled data transparency and reliability. By leveraging Ethereum as a data storage layer, we strive to transform the way the world handles and protects its most critical text records. *** ### Additional Learning Resources & Background * [Data Tokenization](https://mirror.xyz/0xB42dD0878219c3fC356ABe8F7c0800b80147B7a1/wS0v83-Pg1mNinl2xS4p4L2OF5KmBZwithp6SEq8Xxs) * [Enabling End-to-End On-Chain Tokenization](https://mirror.xyz/0xB42dD0878219c3fC356ABe8F7c0800b80147B7a1/KmA6wWuPXbyJYoGiZNrRAFGJcQueid-KSI7-a05kd-g) * [Ethereum as Data Storage Layer](https://mirror.xyz/0xB42dD0878219c3fC356ABe8F7c0800b80147B7a1/2pvtDfOYOrxBRTx3yX97yWVGPIRWav6fkoTGYFZi0jE) * [Tokenize Everything](https://mirror.xyz/0xB42dD0878219c3fC356ABe8F7c0800b80147B7a1/k8HtpkzrqYHZbkxu3jno1rx-yUh9XKw7nt0eAQMdCXU) * [Establishing a Benchmark for Document Provenance](https://mirror.xyz/0xB42dD0878219c3fC356ABe8F7c0800b80147B7a1/Rkl3RdViayRjlwDKMGn1uA1IUo81BTT7aH2V8G9eyGk) # Xyxyx Text-Based Tokenization Architecture (XTBTA) ### Overview The Xyxyx Text-Based Tokenization Architecture (XTBTA) is a software architecture designed for text-based tokenization. XTBTA serves as the underlying architecture of both the [Xyxyx API ](/products-and-services/api)and the [Xyxyx Launchpad](/products-and-services/launchpad). *** ### Functionality **Text Processing** XTBTA normalizes and encodes input text for EVM compatibility. *** **SVG Generation** XTBTA dynamically constructs an SVG document with elements, calculates bounding boxes, and embeds fonts if needed. *** **Gas Optimization** XTBTA minifies SVG, applies path simplifications, and explores compressed storage (Base64, gzip) for efficient on-chain persistence. *** **On-Chain Data Storage** XTBTA stores the final SVG string inside a Solidity smart contract, eliminating reliance on off-chain dependency (e.g., IPFS, Arweave) for data storage. *** **Rendering & Retrieval** Through XTBTA, token data is always retrievable from the EVM itself, being exposed via smart contract methods (`tokenURI`) and directly renderable via `data:image/svg+xml`. # Data Encoding ### Overview The [Xyxyx Text-Based Tokenization Architecture (XTBTA)](/xyxyx-text-based-tokenization-architecture-xtbta) incorporates an entirely blockchain-based framework for the generation and lifecycle management of[ Text-Based Tokens (TBTs)](/text-based-tokens-tbts). Instead of relying on IPFS or centralized servers for metadata storage and retrieval, XTBTA stores all relevant information — including the token’s visual representation — entirely within the Ethereum blockchain. TBTs are visually rendered using SVG (Scalable Vector Graphics), encoded in Base64, and embedded in the smart contract’s metadata delivery. As a result, this ensures each token is fully self-contained, tamper-proof, and persistently accessible. *** ### Key Features #### Base64-Encoded SVG Outputs TBTs utilize SVG to represent token visuals in a scalable, resolution-independent manner. These SVG documents are programmatically generated and encoded in Base64. XTBTA proposes the encoding of each TBT's SVG output into a Base64 string that is embedded in a JSON object, which is itself Base64-encoded and returned as a `tokenURI`. *** #### On-Chain Data Delivery Each TBT implements the `tokenURI()` function as defined by the ERC-721 standard. However, unlike conventional implementations that return a pointer to external JSON metadata, TBTs contracts return a fully self-contained, Base64-encoded metadata object. This object includes the encoded SVG visual and any relevant descriptive fields — delivered entirely from within the smart contract; without the need for off-chain servers. As a result, XTBTA ensures that front-ends, indexers, and explorers can interpret and render the token without accessing any external infrastructure. *** ### Functionality Through XTBTA, each token’s metadata is programmatically constructed and encoded directly within the smart contract. This approach ensures that all descriptive and visual elements — such as the token’s name, description, and image — are embedded on-chain in a self-contained format. The following example illustrates the step-by-step process through which a token’s metadata is constructed, encoded, and prepared for delivery via the `tokenURI` function: 1. **Base64-Encoded Token URI** {% code overflow="wrap" %} ```uri data:application/json;base64,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 ``` {% endcode %} > The `tokenURI` is composed of a Base64-encoded JSON object that contains all the metadata associated with the token. *** 2. **Base64 Decoded to JSON** {% code overflow="wrap" %} ```json {"name": "TBILL-912796WQ4 #4", "description": "", "image": "data:image/svg+xml;base64,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"} ``` {% endcode %} > When the Base64-encoded JSON object is decoded, it reveals a JSON structure in which the `"image"` field contains another Base64-encoded string — representing an embedded SVG image. *** 3. **JSON Base64 Decoded to XML** {% code overflow="wrap" %} ```svg Built on Xyxyx { "token_id": "TBILL-912796WQ4", "issuer": "J.T.", "instrument_type": "Treasury Bill", "term": "13 weeks", "cusip": "912796WQ4", "issue_date": "2025-05-01", "maturity_date": "2025-07-31", "discount_rate": "5.12%", "face_value_usd": 1000, "purchase_price_usd": 987.20, "timestamp": "2025-05-11T15:42:00Z" } TREASURY BILL RECORD---------------------------------------- Issuer: J.T.Instrument: 13-Week T-Bill CUSIP: 912796WQ4 Issue Date: 2025-05-01 Maturity Date: 2025-07-31 Discount Rate: 5.12% Face Value: $1,000 Purchase Price: $987.20 ``` {% endcode %} > Decoding the Base64 string found in the `"image"` field of the JSON metadata produces the XML markup that renders the SVG graphic associated with the token. *** 4. **SVG Output**
> The XML code, once decoded, generates the final SVG output — a visual representation embedded in the token metadata. *** ### Fundamentals #### Immutability All metadata, visuals, and descriptive content related to TBTs are embedded in Ethereum’s state at the time of contract deployment or token minting. This guarantees the permanence and non-repudiation of each token’s identity and attributes. *** #### Reliability By eliminating external storage endpoints, XTBTA avoids common points of failure such as broken links, misconfigured servers, or expired hosting plans. The on-chain-only model substantially reduces operational risk. *** #### Transparency TBTs are fully observable on-chain. Developers and end users can inspect all token attributes, metadata, and rendering logic directly via smart contract interfaces — enabling frictionless auditing and trustless attesting. *** #### Censorship Resistance TBTs access and visibility cannot be obstructed by third-party services or centralized infrastructure providers. *** #### Data Longevity As long as the Ethereum network persists, all TBTs data remains accessible and verifiable, ensuring digital persistence without reliance on third-party hosting or re-indexing services. *** #### **Auditability** All state changes, token interactions, and logic executions are recorded immutably on-chain. This enables verifiable and reproducible audits by any third party without requiring privileged access. *** #### **Attestability** Users and systems can cryptographically attest to the authenticity and provenance of TBTs based solely on their on-chain presence. This trustless verification model removes reliance on off-chain registries or authorities. *** #### **Composability** TBTs are designed to be both immutable blockchain records and highly composable data files. Their SVG-based structure allows them to be easily accessed and integrated into other applications or systems, facilitating seamless interoperability and reuse in various contexts. *** ### **On-Chain Data Storage** Through XTBTA, 100% of each token’s data is stored fully on-chain, ensuring immutability, transparency, and complete independence from external, off-chain data storage systems such as IPFS. Below we provide a comparison table between on-chain vs. off-chain data storage: | Criteria | On-Chain Data Storage | Off-Chain Data Storage | | ------------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------- | | **Immutability** | Fully immutable once minted; embedded in Ethereum state | Content is immutable (via content hash), but links can be changed by referencing new hashes | | **Availability** | Guaranteed as long as the Ethereum network exists | Requires external pinning to ensure persistent availability | | **Censorship Resistance** | Cannot be removed or blocked | Resistant to censorship, but depends on gateway access or node hosting | | **Reliability** | No external dependencies or servers needed | Relies on external nodes and pinning services | | **Transparency** | 100% transparent and queryable via smart contracts | Metadata is viewable if hash is known, but less transparent in contract context | | **Performance** | Fast read access on-chain; no external lookups | Requires external fetch, which may introduce latency | | **Auditability** | Fully auditable and verifiable on-chain | Auditable if hash is on-chain, but file contents need off-chain verification | | **Data Longevity** | Data lives as long as Ethereum does | Data longevity depends on pinning and external upkeep | # Data Architecture ### Overview The [Xyxyx Text-Based Tokenization Architecture (XTBTA)](/xyxyx-text-based-tokenization-architecture-xtbta) introduces a structured, multi-layered approach to embedding both visual and semantic data within each [Text-Based Token](/text-based-tokens-tbts). Rather than treating token content as a single flat layer, XTBTA separates human-facing presentation from system-readable metadata at the architectural level. This is achieved through an SVG-based data model that distinguishes between two complementary data types: **Token Text** and **Metadata Text**. Each TBT is composed using dedicated SVG elements — `` for visible, user-generated content, and `` for metadata meant for programmatic consumption. This layered structure enables the token to serve dual purposes: as a visually expressive artifact and as a carrier of structured, queryable information. By embedding both layers directly within the smart contract, XTBTA facilitates rich interaction across interfaces — from user-facing applications to backend indexing systems — without compromising decentralization or on-chain permanence. *** ### Data Layering XTBTA employs a dual-input model comprising two distinct text functions for composing TBTs: [Token Text](/text-based-tokens-tbts#token-text) and [Metadata Text](/text-based-tokens-tbts#metadata-text), each targeting a specific layer of data representation within the on-chain SVG architecture. * The **Token Text** function allows users to input free-form text that is rendered visually within the SVG graphic of the token. This content is directly inserted into the SVG markup and becomes part of the token's visible, human-readable output — making it ideal for declarative content that should be perceivable at the presentation layer of the token. * In contrast, the **Metadata Text** function is designed for system-readable content. It embeds a text record inside the SVG file but not as part of the visible image. Instead, it is included as structured data within the token’s `tokenURI` metadata field, stored either as raw text or in standardized formats like JSON. This allows developers and off-chain systems to parse and interpret token-specific attributes, logic, or additional semantic data. For example, **Metadata Text** can encapsulate a JSON object that mirrors or expands on the **Token Text** content, enabling machine-readable access to the token’s semantics without altering its visual representation. As a result, TBTs can be leveraged in a wide range of interoperable applications — from human-facing interfaces to automated indexing, querying, or integration with external data pipelines. *** ### Data Structure XTBTA composes each TBT using a layered SVG-based data structure that cleanly separates human-readable content from machine-readable metadata. This is achieved through the use of two distinct SVG elements — `` and `` — each serving a specific role in the token's on-chain representation. 1. ``: The description element is for [Metadata Text](/text-based-tokens-tbts#metadata-text). 2. ``: The text element is for [Token Text](/text-based-tokens-tbts#token-text). **Example** **SVG Output**
**SVG File** {% code overflow="wrap" %} ```svg Built on Xyxyx { "token_id": "TBILL-912796WQ4", "issuer": "J.T.", "instrument_type": "Treasury Bill", "term": "13 weeks", "cusip": "912796WQ4", "issue_date": "2025-05-01", "maturity_date": "2025-07-31", "discount_rate": "5.12%", "face_value_usd": 1000, "purchase_price_usd": 987.20, "timestamp": "2025-05-11T15:42:00Z" } TREASURY BILL RECORD---------------------------------------- Issuer: J.T.Instrument: 13-Week T-Bill CUSIP: 912796WQ4 Issue Date: 2025-05-01 Maturity Date: 2025-07-31 Discount Rate: 5.12% Face Value: $1,000 Purchase Price: $987.20 ``` {% endcode %} **Where** `` : ```json { "token_id": "TBILL-912796WQ4", "issuer": "J.T.", "instrument_type": "Treasury Bill", "term": "13 weeks", "cusip": "912796WQ4", "issue_date": "2025-05-01", "maturity_date": "2025-07-31", "discount_rate": "5.12%", "face_value_usd": 1000, "purchase_price_usd": 987.20, "timestamp": "2025-05-11T15:42:00Z" } ``` *** `` : ``` TREASURY BILL RECORD ---------------------------------------- Issuer: J.T. Instrument: 13-Week T-Bill CUSIP: 912796WQ4 Issue Date: 2025-05-01 Maturity Date: 2025-07-31 Discount Rate: 5.12% Face Value: $1,000 Purchase Price: $987.20 ``` # Text-Based Tokens (TBTs) ### Overview Text-Based Tokens (TBTs) are tokens with an embedded text record. Every text-based token has a bonded Base64-encoded SVG output, which is embedded in the token’s metadata and stored entirely on blockchain rails. As a result, text-based tokens offer a fully blockchain-based solution for text records storage, eliminating the need for off-chain hosting services like IPFS. * [Data Encoding](/xyxyx-text-based-tokenization-architecture-xtbta/data-encoding) * [Data Architecture](/xyxyx-text-based-tokenization-architecture-xtbta/data-architecture) *** ### Key Features #### On-Chain Data Storage Text-based tokens are generated, rendered, and stored entirely on-chain, ensuring the highest level of data integrity and provenance (i.e., immutability and permanence). *** #### Composability Composability is a key feature of text-based tokens. On the one hand, the data of each text-based token is cryptographically stored on Ethereum, while on the other, it can be effortlessly accessed at any time and managed as an SVG file. This duality allows text-based tokens to serve as both immutable, permanent blockchain records and highly composable data files. *** #### Multilingual Text-based tokens support the use of text from all of the world's digitized writing systems, whether it’s Japanese, Arabic, Russian, Korean, or Chinese. *** ### Input Functions Text-based tokens contain two input text functions: **Token Text** and **Metadata Text.** For a deeper understanding of Input Functions, refer to [Data Layering](/xyxyx-text-based-tokenization-architecture-xtbta/data-architecture#data-layering) and [Data Structure](/xyxyx-text-based-tokenization-architecture-xtbta/data-architecture#data-structure). #### **Token Text** > The text record inserted into the token SVG output. The **Token Text** input function allows the insertion of a text record into a token's SVG output. *** #### **Metadata Text** > The text record inserted into the token metadata, stored within its SVG file. The **Metadata Text** input function allows the insertion of a text record bonded to a token's metadata, which is stored within its SVG file. Text records entered through the **Token Text** input function are encapsulated within the token's `tokenURI` metadata and encoded in Base64. In contrast, text records inserted via the M**etadata Text** input function are stored in the token's `tokenURI` metadata as plain text. This enables, for example, the inclusion of a JSON file within the token's metadata, which is stored inside its SVG file. Since JSON is a universal format, users can leverage the **Metadata Text** function to add structured attributes and properties, facilitating composability with non-blockchain (or "off-chain") systems. **Example** {% code overflow="wrap" %} ```json { "name": "Token 7632", "symbol": "D7632", "text": "Token 7632 - 2025-01-10\n - \n Lorem ipsum dolor sit amet. Et ipsa \n dolores cum suscipit dolorum est \n quaerat laudantium eos dolor labore\n ut perspiciatis reprehenderit ab \n accusamus dolor. Et cupiditate\n accusantium sed aliquam numquam\n et maiores unde." } ``` {% endcode %} # Tokenization Models Tokenization models are frameworks that define how [Text-Based Tokens](/text-based-tokens-tbts) are structured. Xyxyx introduces two foundational tokenization models — 1x1 and A4 —, which adhere to different intended use cases.
ModelDescription
1x1A model for tokenizing short text records
A4A model for tokenizing long text records
# 1x1 ### Overview The 1x1 tokenization model allows for the creation of text-based tokens in the 1:1 output format. * [Specifications](/tokenization-models/1x1/specifications) *** ### Key Features #### Highly Customizable The 1x1 model is highly customizable in defining token design. 1x1 SVG outputs can include (1) the insertion of a logo; (2) the insertion of a background watermark; (3) a custom background color; (4) a custom text color; (5) a custom border radius, and (6) a custom text font family. *** ### Intended Use Cases The 1x1 tokenization model is designed for tokenizing short text records. 1x1 text-based tokens can be used in a variety of applications, ranging from AI and finance to general data. *** #### AI 1x1 can be integrated as part of AI-related frameworks. 1x1 enables that short text records generated during AI-related processes to be permanently recorded, offering unparalleled data provenance and integrity — from AI model prompts to AI agent interactions.
*** #### Data 1x1 can be integrated into any system to capture and record critical data, ensuring provenance, transparency, permanence, accountability, and auditability.
*** #### **Finance** 1x1 can be employed as a building block for tokenizing RWAs and traditional financial instruments, with each token standard — [ERC-721F](/token-standards/erc-721f), [ERC-404](/token-standards/erc-404), and [ERC-721](/token-standards/erc-721) — offering distinct foundational properties tailored to different use cases.
# Specifications
*** ### Overview | Aspect | Attribute | | ------------- | --------- | | MIME type | SVG | | Token URI | Base64 | | Output Format | 1:1 | | Output Size | 300x300 | *** ### **Parameters**
NameDescriptionOptions
backgroundDefines the background color that will stamp every 1 full token issued by the smart contractAny Hex color, defaults to #000000
textColorDefines the text color that will stamp every 1 full token issued by the smart contractAny Hex color, defaults to #FFFFFF
fontDefines the text font family that will stamp every 1 full token issued by the smart contractserif, sans-serif or monospace, defaults to monospace
#### **Advanced options**
NameDescriptionOptions
Show deployer addressInsert the deployer address in the token outputoptional
Border radiusCustomize the border radius of the token outputFrom 0 to 20px, defaults to 0
Upload logoInsert a logo in the token outputAny 1:1 SVG file
Upload watermarkInsert a background watermark in the token outputAny 1:1 SVG file
TrademarkInsert an Xyxyx trademark in the token outputoptional
*** ### Content Capacity #### **Token Text** * Max of 45 characters per line of text * Max of 22 lines of text * Max of (aprox.) 1,010 characters #### **Metadata Text** * Max of (aprox.) 4,500 characters # A4 ### Overview The A4 tokenization model allows for the creation of text-based tokens in the A4 output format. * [Specifications](/tokenization-models/a4/specifications) *** ### Key Features #### Multiple Pages The A4 model is designed to consolidate multiple outputs into a single text-based token, incorporating a built-in pagination system. As a result, A4 enables the tokenization of documents with multiple pages. *** ### Intended Use Cases The A4 tokenization model is designed for tokenizing long text records (e.g., documents). It is intended for use cases where a document requires the highest levels of immutability, permanency, attestability, and auditability of text records. This is particularly applicable in critical contexts that demand the utmost data provenance and integrity. *** #### Legal A4 can be used for tokenizing traditional critical legal documents, such as contracts, financial statements, title deeds, and patents.
*** #### AI A4 can be integrated into AI-related frameworks, enabling the permanent recording of long text records generated during AI processes. This ensures unparalleled data provenance and integrity — from tokenizing AI model performance reports, explanation documents, and versioning, to tokenizing compliance audits, algorithmic intellectual property (IP), and data provenance and lineage.
*** #### Literature A4 can be used for tokenizing critical literature documents, such as research articles, academic papers, technical whitepapers, and manifestos.
# Specifications
*** ### Overview | Aspect | Attribute | | ------------- | --------- | | MIME type | SVG | | Token URI | Base64 | | Output Format | A4 | | Output Size | 212x300 | *** ### **Parameters**
NameDescriptionOptions
fontDefines the text font family that will stamp every 1 full token issued by the smart contractserif or sans-serif, defaults to serif
titleDefines the title of the documentoptional
subtitleDefines the subtitle of the documentoptional
*** ### Content Capacity #### **Token Text** * Max of 67 characters per line of text * Max of (aprox.) 111 lines of text * Max of (aprox.) 7,540 characters #### **Metadata Text** * Calculate 7,540 minus the number of characters inserted in the **Token Text**. The result will be the remaining content capacity for the **Metadata Text**. # Token Standards Xyxyx's tokenization models (1x1 and A4) can be built upon three token standards — ERC-721F, ERC-404, and ERC-721 —, which adhere to different intended use cases.
StandardDescription
ERC-721FThe ERC-721F is a variant of the ERC-721 standard developed by Xyxyx. ERC-721F is designed to provide highly customizable token issuance by assigning each token an individualized SVG output (svgString) at the time of minting.
ERC-404The ERC-404 is a hybrid token standard that combines the functionalities of the ERC-721 standard (non-fungible tokens) and the ERC-20 standard (fungible tokens).
ERC-721The ERC-721 is a non-fungible token standard.
# ERC-721F The ERC-721F is a variant of the ERC-721 standard developed by Xyxyx. ERC-721F is designed to provide highly customizable token issuance by assigning each token an individualized SVG output at the time of minting. * [Parameters](/token-standards/erc-721f/parameters) * [ERC-721F GitHub Repository](https://github.com/xyxyxpro/ERC-721F/) *** ### Introduction to ERC-721F Traditional ERC-721 contracts operate under a monolithic token metadata architecture. Token URIs are either hardcoded into the smart contract or derived through deterministic logic, which limits the ability to introduce per-token variability. Moreover, reliance on off-chain resources such as IPFS introduces issues related to availability, mutability, and provenance. Built by Xyxyx, the ERC-721F standard takes a fundamentally different approach. By delegating metadata construction to the `mint` function — and by allowing external systems to inject token-specific metadata at runtime — the standard promotes a modular and extensible architecture. For that, the ERC-721F integrates native Base64 encoding within the `tokenURI` schema as default. *** ### **svgString** The core functionality of ERC-721F is a parameter called `svgString`, which is encapsulated in the `mint` function. `svgString` permits the definition of `tokenURI`s at the time of token issuance, bypassing traditional metadata bottlenecks. As a result, ERC-721F enables the creation of highly customized and self-contained tokens that, on the one hand, do not depend on off-chain infrastructure for data storage and, on the other hand, can be composable with any existing external system for data input. *** ### ERC-721F and Xyxyx API Unlike traditional ERC-721 contracts where the metadata URI is statically embedded, ERC-721F delegates metadata construction to external systems through the minting process. This design principle reflects a modular and extensible architecture, where third-party applications can dynamically determine token characteristics at runtime. The ERC-721F standard is designed for seamless integration with the [Xyxyx API](/products-and-services/api), a REST API developed to automate and simplify the creation of contract deployments and injection of `svgString` values during the minting process. By leveraging the Xyxyx API, the ERC-721F can be leveraged to programmatically generate and assign complex on-chain metadata to tokens, reducing the need for manual metadata construction and enabling integration with any existing system. *** ### Conclusion By decoupling metadata from rigid contract logic and empowering external systems to participate in metadata construction, ERC-721F provides advancements in modularity, extensibility, and metadata composability with any existing system. Through ERC-721F, smart contracts no longer dictate the entirety of token metadata. Instead, they serve as programmable shells into which structured, dynamic data can be injected by any existing system — unlocking a wide range of potential interactions and designs. # Parameters
NameDescriptionDefault
nameDefines the name of the smart contractrequired
symbolDefines the symbol of the token to be issued by the smart contractrequired
supplyDefines the max supply. If set to 0, the collection has infinite supply.0 or e.g., 10000
mintPriceDefines the minting cost per token. If set to 0, the minting is free.0 or e.g., 0.05 ETH
restrictToOwnerIf set to true, only the contract owner can mint tokens. If false, minting is public.true or false
# ERC-404 The [ERC-404](https://github.com/Pandora-Labs-Org/erc404) is a hybrid token standard that combines the functionalities of the ERC-721 standard (non-fungible tokens) and the ERC-20 standard (fungible tokens). This means that ERC-404 smart contracts can be seamlessly integrated into any ERC-20 or ERC-721 application (i.e., Uniswap or OpenSea). By combining the functionalities of both ERC-721 and ERC-20 tokens standards, ERC-404 smart contracts can be highly customizable in defining token economics, which can range from unique, indivisible items (`0` decimals) to widely distributable assets with varying levels of granularity (from `1` to `18` decimals). Xyxyx introduces a fully blockchain-based version of the ERC-404 standard, featuring native Base64-encoded SVG outputs as the `tokenURI`. * [Parameters](/token-standards/erc-404/parameters) # Parameters
NameDescriptionDefault
nameDefines the name of the smart contractrequired
symbolDefines the symbol of the token to be issued by the smart contractrequired
supplyDefines the total supply of the token to be issued by the smart contractrequired (from 1 to ∞)
decimalsDefines the decimals of the token to be issued by the smart contractrequired (from 0 to 18)
# ERC-721 The ERC-721 is a non-fungible token standard. Xyxyx introduces a fully blockchain-based version of the ERC-721 standard, featuring native Base64-encoded SVG outputs as the `tokenURI`. * [Parameters](/token-standards/erc-721/parameters) # Parameters
NameDescriptionDefault
nameDefines the name of the smart contractrequired
symbolDefines the symbol of the token to be issued by the smart contractrequired
supplyDefines the max supply. If set to 0, the collection has infinite supply.0 or e.g., 10000
mintPriceDefines the minting cost per token. If set to 0, the minting is free. 0 or e.g., 0.05 ETH
restrictToOwnerIf set to true, only the contract owner can mint tokens. If false, minting is public.true or false
# API The Xyxyx API is a REST API for building text-based tokenization applications. The API is designed on top of the [Xyxyx Text-Based Tokenization Architecture (XTBTA)](https://docs.xyxyx.pro/introduction/xyxyx-text-based-tokenization-architecture-xtbta). For further understanding about the API, please refer to our [Developer Documentation](https://developer.xyxyx.pro/). # Boilerplate ### Overview The Xyxyx Tokenization Boilerplate (XTB) is a text-based tokenization boilerplate designed to run on the Xyxyx API. XTB is a script that streamlines the process of minting a text-based token arbitraged by a `#` system via the [Xyxyx API](/products-and-services/api) and a `#` system's [ERC-721F](/token-standards/erc-721f) contract incorporated for the task — where `#` can be any existing system. * [XTB GitHub Repository](https://github.com/xyxyxpro/XTB) *** ### Functionality The script that embodies XTB is structured into three modules:
1. **Data Source Module:** The Data Source Module is the module that generates the source text data to become tokenized. The module can be composed by any existing system. The Data Source Module generates text data and sends it as a request to the Central Module (see item 2) to be tokenized by the Tokenization Module (see item 3). 2. **Central Module:** The Central Module is the module that receives text data inputs from the Data Source Module and sends it to become tokenized by an on-chain module called the Tokenization Module (see item 3). Fundamentally, the Central Module is incorporated by the Xyxyx API, which processes and forwards the text data received from the Data Source Module in a fully structured manner to become tokenized in the next step of the tokenization process. 3. **Tokenization Module:** The Tokenization Module is the module that transforms text data generated from the Data Source Module and parsed by the Central Module into text-based tokens. The Tokenization Module is embodied by an ERC-721F smart contract deployed for this task. Such ERC-721F contract issues the text-based tokens that reflect the source text data requested by the Data Source Module, based on instructions and arguments parsed by the Xyxyx API. *** ### **Xyxyx API POC** XTB is conceived as an Xyxyx API POC. We built a simple implementation of the XTB that employs an automated X account as the **Data Source Module** for embodying the POC. In turn, the X account generates the source text data (i.e., posts) as requests, communicating with the Xyxyx API via the X API. In short, every post made by the automated X account results, via Xyxyx API, in a request for issuance of a reflective text-based token by an ERC-721F smart contract deployed for the POC. The tokenization process is fully automatized, requiring no human management. **POC Execution** The POC spanned for 10 days, running from February 19th to March 1st, 2025, on Arbitrum One. * The automated X account used in the POC can be found [here](https://x.com/xtb_poc) (@xtb\_poc). * See xtb\_poc on Xyxyx Explorer [here](https://www.xyxyx.pro/explorer/tokens?ca=0xf34aa9a2d6dcd7f8f800667003bbcc4a6cfe55e0\&chain=arbitrum). During the 10-day execution period, the automated X account posted ten times per day, resulting in the issuance of 100 text-based tokens by the ERC-721F contract upon the conclusion of the POC. The posts from the automated X account consisted on a timestamp of the current date and time. **Example** `2/16/2025, 11:38:48 PM (UTC)` # Launchpad Version: 3.3 *** {% hint style="info" %} Deployments on the Xyxyx Launchpad are restricted to [XINs](/protocol/xyxyx/xyxyx-issuer-nodes-xins). {% endhint %} {% hint style="success" %} The Xyxyx Launchpad is evolving into a suite of mini apps. [Learn more](https://mirror.xyz/0xB42dD0878219c3fC356ABe8F7c0800b80147B7a1/6hD59Z5o9YTyzG6sW-D-pY5tK_kcaoS4Xa1_XECZFH8) {% endhint %} ### Overview The [Xyxyx Launchpad](https://www.xyxyx.pro/launchpad) is a state-of-the-art platform for text-based tokenization, providing user interfaces specifically designed for building on Xyxyx. The platform is built on top of the [Xyxyx Text-Based Tokenization Architecture (XTBTA)](https://docs.xyxyx.pro/introduction/xyxyx-text-based-tokenization-architecture-xtbta). Xyxyx Launchpad is available on Ethereum Mainnet, Arbitrum One, Base Mainnet, and OP Mainnet, as well as on testnets (Ethereum Sepolia, Arbitrum Sepolia, Base Sepolia, and OP Sepolia). *** ### Interfaces
InterfaceDescription
1x1 UIA user interface for building upon the 1x1 tokenization model.
A4 UIA user interface for building upon the A4 tokenization model.
*** ### Compatibility The Xyxyx Launchpad is available in Desktop and Mobile versions. # Using Launchpad {% hint style="info" %} The Xyxyx Launchpad is live on Ethereum Mainnet, OP Mainnet, Base Mainnet, and Arbitrum One, and on Testnets (Sepolia, OP Sepolia, Base Sepolia, and Arbitrum Sepolia). {% endhint %} {% hint style="warning" %} The Xyxyx Launchpad currently supports only [ERC-404](/token-standards/erc-404) smart contract deployments. {% endhint %} ### 1. Connecting **1.1** Access the Xyxyx Launchpad via [xyxyx.pro/launchpad](https://www.xyxyx.pro/launchpad). **1.2** Choose a tokenization model: **1x1** or **A4**. **1.3** Click on the **Continue** button. **1.4** Connect your wallet by clicking the **Connect** button on the upper left of the interface. **1.5** Approve the interaction with ****. *** ### 2. Customizing **2.1** Define the **Parameters** that will compose the smart contract. **2.2** Input the **Token text**. **2.3** Input the **Metadata text**. **2.4** Double-check all writings and parameters entered in the interface. *** ### 3. Deploying **3.1** Click on the **Deploy** button. **3.2** Approve the transaction that will deploy the smart contract onto the blockchain. **3.3** Visit the Etherscan page of the smart contract deployed by clicking on the address prompted in the **Deployed contracts** tab. *** ### 4. Managing **4.1** On MetaMask, click in the **Tokens** tab, and import a new token by inserting the smart contract address of the smart contract deployed on the Xyxyx Launchpad. **4.2** The entire token supply of the contract is automatically minted to the deployer address (as an ERC-20 token) at the time the smart contract is deployed. **4.3** Transfer at least 1 full token to a new address to init the ERC-721 side of the smart contract. For instance, when first transferring 5 full tokens, the #1, #2, #3, #4, and #5 tokens (as ERC-721) will be minted in the wallet of the receiver address. While not executing any transfer of 1 full token, only the ERC20 side is initialized in the smart contract. **4.4** After executing the transfer of at least 1 full token, the ERC-721 token(s) minted by the smart contract can be visualized via Etherscan or via OpenSea. URL examples: * **etherscan.io/nft/**`CA`**/**`tokenID` * **opensea.io/assets/ethereum/**`CA`**/**`tokenID` *** ### Annotations #### No fees The Xyxyx Launchpad does not charge any fees for deployments. All the costs incurred within using the platform are strictly related to the Ethereum network fees. #### Deployment gas costs The gas consumption incurred to deploy each smart contract on the Xyxyx Launchpad is proportional to the number of characters typed in both **Token Text** and **Metadata Text** input functions. This means that as longer the texts on both **Token Text** and **Metadata Text** input functions, the higher the byte size of the smart contract and the gas costs incurred to deploy it. {% hint style="danger" %} Please note that the maximum size for a contract on Ethereum is 24,576 bytes, or 24 kilobytes (KB). If a contract's bytecode is larger than this, the deployment will fail. {% endhint %} *** > Need help? Contact us at or join our [Telegram](https://t.me/Xyxyx404). # Usage Policies We aim for the Xyxyx Launchpad to be used safely and responsibly while maximizing the user's control over how he uses it. By using our services, you agree to adhere to our policies. We cannot predict all beneficial or abusive uses of our technology. From that, our usage policies will evolve based on what we learn over time. ### Policies To maximize innovation and creativity, we believe users should have the flexibility to use the Xyxyx Launchpad as they see fit, so long as users comply with the law and don’t harm others. When using the Xyxyx Launchpad, these rules apply:
1. **Comply with applicable laws** — for example, don’t compromise the privacy of others, engage in regulated activity without complying with applicable regulations, or promote or engage in any illegal activity. 2. **Don’t use our service to harm yourself or others** — for example, don’t use the Xyxyx Launchpad to promote or engage in unauthorized activities that violate the security of any service or system. 3. **Don’t repurpose or distribute output from our services to harm others** — for example, don’t share output from the Xyxyx Launchpad to defraud, scam, spam, mislead, bully, harass, defame, discriminate others. 4. **Respect our safeguards** — don’t circumvent safeguards or safety mitigations in the Xyxyx Launchpad. ### Building with Xyxyx Launchpad The Xyxyx Launchpad allows users to build entirely custom tokenization components. As the developer, users are responsible for designing and implementing how their users interact with our technology. We recognize that the Xyxyx Launchpad introduces new capabilities with scalable impact, so we have service-specific policies that apply to all uses of our technology: 1. Don’t misuse our platform to cause harm by intentionally deceiving or misleading others, including: * i. **Generating or promoting disinformation or misinformation** * ii. **Impersonating another individual or organization without consent or legal right** * iii. **Engaging in or promoting academic dishonesty** *** > For anything else, please contact us at . # Xy ### Overview Xy is a generative AI tool fine-tuned to assist users in creating tokenization templates, natively integrated into the [Xyxyx Launchpad](/products-and-services/launchpad). Xy is powered by OpenAI's GPT-3.5 Turbo. *** ### Fine-Tuning Xyxyx has bifurcated Xy's fine-tuning into two model prompts to individually adhere to each one of its two tokenization models ([1x1 ](/tokenization-models/1x1)and [A4](/tokenization-models/a4)). The pretraining and fine-tuning were based on 1x1 and A4 respective frameworks and intended use cases, being conceptually focused on tokenization templates. *** ### Using Xy Users can get assistance from Xy via a prompt bar embedded in the ‘**Input token text**’ input function of both the 1x1 and A4's web interfaces. As with any AI, the more specific users are with prompts and context, the better the results Xy can provide. Remember to give Xy clear and concise instructions, which may be in context with the intended use cases of both launchpad’s interfaces. If you don’t get exactly the answer you’re looking for, try wording your query/prompt a different way. ### **Prompt examples** #### 1x1 * `Template for tokenized real estate certificates` * `Template for tokenized artwork certificates` * `Template for tokenized land certificates` * `Template for tokenized rare item certificates` #### A4 * `Template for tokenized real estate contract terms` * `Template for tokenized artwork contract terms` * `Template for tokenized land contract terms` * `Template for tokenized rare item contract terms` {% hint style="info" %} Please note that the outputs generated by Xy should be treated with caution for potential inaccuracies or errors. {% endhint %} *** ### Status Xy is a static model trained and fine-tuned by Xyxyx on an offline dataset. Until its integration into the Xyxyx Launchpad (v1.2), Xy was trained for 3 weeks on over 10 thousand tokens of data. The pretraining and fine-tuning included data from publicly available sources, conceptually focused on tokenization templates; ranging from share certificates to legal documents. The training and fine-tuning of Xy is a constant process executed by Xyxyx. From that, future versions of Xy will be released as we improve its efficiency through research and community feedback. *** ### Misuse If you use Xy, you agree to the [Usage Policies](https://docs.xyxyx.pro/launchpad/using-xyxyx/usage-policies). # Changelog > The desktop and mobile versions of the Xyxyx Launchpad are being developed concurrently.
Networks * **Testnets (Ethereum Sepolia, OP Sepolia, Base Sepolia, Arbitrum Sepolia) - January 31st, 2025** * **Arbitrum One - December 20th, 2024** * **Base Mainnet - December 17th, 2024** * **OP Mainnet - December 13th, 2024** * **Ethereum Mainnet - March 22nd, 2024**
*** **Version 3.3 - November 28th, 2024** * Enabled the insertion of an Xyxyx trademark (optional) on 1x1-based outputs * Reworked 1x1's 'Show deployer address' feature * Added a dedicated modal for the 'Deployed contracts' section *** **Version 3.2 - October 03rd, 2024** * Released an upgraded version of the A4 tokenization model * Enabled the insertion of a 'Document title' and 'Document subtitle' on A4-based outputs *** **Mobile Version - September 20th, 2024** * Released the Xyxyx Launchpad Mobile, a mobile version of xyxyx.pro/launchpad *** **Version 3.1 - September 13th, 2024** * Implemented the Xyxyx Issuer Nodes (XINs) platform architecture *** **Version 3.0 - August 14th, 2024** * Released the next generation of the 1x1 tokenization model * Enabled the insertion of a background watermark on 1x1-based outputs * Enabled the insertion of a logo on 1x1-based outputs * Reworked UI of 1x1's 'Border radius' feature * Reworked the HEX color display of 1x1's 'Background' and 'Text' color features * Reworked the Xy input bar *** **Version 2.1 - July 9th, 2024** * Reworked UI and UX of Version 2.0 * Added 'Feedback' tab *** **Version 2.0 - May 31st, 2024** * Released a new UI and UX * Added 1x1's 'Border radius' feature *** **Version 1.2 - May 09th, 2024** * Released Xyxyx's AI, Xy *** **Version 1.1 - April 11th, 2024** * Incorporated the A4 tokenization model *** **Version 1.0 - March 22nd, 2024** * Released the Xyxyx Launchpad interface * Incorporated the 1x1 tokenization model # Tokenizer ### Overview The Xyxyx Tokenizer is a component designed to integrate text-based tokenization into React applications, powered by the Xyxyx API. * [Developer Documentation](https://developer.xyxyx.pro/utilities/xyxyx-web-components/tokenizer) * [xyxyx-web-components Package](https://www.npmjs.com/package/xyxyx-web-components) * [Xyxyx Tokenizer GitHub Repository](https://github.com/xyxyxpro/xyxyx-web-components/tree/main/src/components/XyxyxTokenizer) *** ### Introduction to Xyxyx Tokenizer The Xyxyx Tokenizer is a text-based tokenization component built on top of Xyxyx's infrastructure stack, which includes the [Xyxyx API](https://developer.xyxyx.pro/), the [xyxyx-web-components](https://github.com/xyxyxpro/xyxyx-web-components) package, and [1x1](https://docs.xyxyx.pro/products-and-services/tokenization-models/1x1). Tokenizer is the first component of the Xyxyx Web Components package. It offers an intuitive interface that simplifies and streamlines the process of deploying smart contracts and issuing text-based tokens. Specifically tailored to the 1x1 tokenization model, Xyxyx Tokenizer enables seamless integration of text-based tokenization into any React application, leveraging the Xyxyx API for execution under the hood. Architecturally, the Xyxyx Tokenizer offers a lightweight, composable building block for developers to leverage the 1x1 tokenization model as a core component in their applications.
*** ### Key Features #### **Seamless integration** Xyxyx Tokenizer enables developers to integrate 1x1 smart contract deployment and token issuance into any React application, with the Xyxyx API handling the execution behind the scenes. *** #### **SVG previews** Xyxyx Tokenizer generates 1x1 token previews in SVG format, allowing for visual representation of text-based tokens before deployment. *** #### **Enhanced error handling and state management** Xyxyx Tokenizer comes with built-in error handling and state management, making contract deployment and token issuance smoother. *** #### **Customizable** **UI** Developers can customize Xyxyx Tokenizer’s UI to align with their system design (colors, borders, font, button label, etc.). # Explorer Version: Beta {% hint style="info" %} Please note that the Xyxyx Explorer strictly indexes contracts that were deployed via Xyxyx, which includes the Xyxyx API and Xyxyx Launchpad. This means that smart contracts not deployed via Xyxyx will not be reflected within the explorer. {% endhint %} ### Overview The Xyxyx Explorer is the native platform for exploring and searching deployments on Xyxyx. The platform is purpose-build for text-based tokenization. The Xyxyx Explorer addresses a critical gap left by general-purpose blockchain explorers like Etherscan and OpenSea, which are not equipped to fully support the unique structure and functionality of [Text-Based Tokens](/text-based-tokens-tbts). Purpose-built for the [Xyxyx Text-Based Tokenization Architecture (XTBTA)](/xyxyx-text-based-tokenization-architecture-xtbta), the explorer offers direct access to core text-based tokenization fundamentals, such as downloading the embedded SVG image of each text-based token, inspecting its Base64-encoded `tokenURI`, and inspecting its data layering. [xyxyx.pro/explorer](https://www.xyxyx.pro/explorer) is available on Ethereum Mainnet, Arbitrum One, Base Mainnet, and OP Mainnet, as well as on testnets (Ethereum Sepolia, Arbitrum Sepolia, Base Sepolia, and OP Sepolia). *** ### Key Features #### **Native Support for Text-Based Tokenization** The Xyxyx Explorer is tightly integrated with the [XTBTA](/xyxyx-text-based-tokenization-architecture-xtbta), natively supporting the unique structure of [TBTs](/text-based-tokens-tbts). including layered SVG data (see [Data Layering](/xyxyx-text-based-tokenization-architecture-xtbta/data-architecture#data-layering)). *** #### **Inline Base64 Decoder** Users can inspect the raw Base64-encoded JSON metadata of each text-based token and decode it directly within the interface. This allows for seamless, transparent verification of each text-based token's`tokenURI` output. *** #### **SVG Download & Preview** Each text-based token’s on-chain SVG is rendered in-browser and also made available for download by the platform. This feature highlights the permanence and self-containment of TBTs by letting users extract the SVG file bonded to each text-based token as an immutable digital artifact — without needing to query external data file servers. *** #### **Metadata Layer Inspection** The Xyxyx Explorer distinguishes between the [Token Text](/text-based-tokens-tbts#token-text) (human-readable content) and [Metadata Text](/text-based-tokens-tbts#metadata-text) (system-level content stored at a data file level). The platform allows for clear separation of user-facing semantics and developer-relevant data, in line with XTBTA's layered data architecture. *** ### Xyxyx Explorer and A4 One of the key advancements supported by the Xyxyx Explorer is its native compatibility with the [A4 ](/tokenization-models/a4)tokenization model — a model specifically designed for encapsulating long-form, document-style text data. The A4 model enables multi-page textual content to be rendered in a paginated SVG layout, preserving the structure and readability of complex documents. Unlike general-purpose explorers such as Etherscan and OpenSea — which cannot natively handle this pagination SVG feature — the Xyxyx Explorer provides a tailored viewing experience, allowing users to paginate through and interact with A4-rendered tokens directly within the interface. Explore how it works in this video demo [here](https://twitter.com/xyxyxpro/status/1917625592515617008). *** ### URL Structure The Xyxyx Explorer URLs are structured as follows: #### **Contracts** address}`\&chain=`{Network}\` > Directs the user to the main contract view, where all tokens minted under the specified contract are listed and accessible. *** #### **Tokens** address}`\&chain=`{Network}`\&tokenId=`{Token Id}\` > Opens the detailed view of a specific text-based token, rendering its Base64 metadata, SVG output, and associated metadata text on a dedicated page. *** ### Compatibility The Xyxyx Explorer is available in Desktop and Mobile versions. # XYXYX ### Overview XYXYX are 128 ERC-404 tokens. *** ### Utility #### Xyxyx Issuer Nodes (XINs) [Xyxyx Issuer Nodes (XINs)](#xyxyx-issuer-nodes-xins) are incorporated via XYXYX, enabling node operators to be the only entities allowed to execute deployments on the Xyxyx Launchpad. Additionally, XIN operators have access to the Xyxyx API. #### Governance XYXYX tokenholders manage the Xyxyx Protocol via [Xyxyx DAO](/protocol/governance). *** ### Key Features #### ERC-20-and-ERC-721-Compliant Built upon the ERC-404 standard, XYXYX comprises features of both ERC-20 and ERC-721 standards. #### Fractionalization XYXYX has 18 decimals, meaning that the token can be subdivided into fractions of up to 0.000000000000000001 XYXYX. #### Fully On-Chain XYXYX is executed and stored entirely on-chain. Every 1 full XYXYX is embodied through a Base64-encoded SVG output that is embedded in the token metadata and stored on the blockchain. #### Built-In Hash Function The XYXYX smart contract introduces a built-in token-ID-based hash function called [XYHASH](/protocol/xyxyx/xyhash), which cryptographically ensures the visual uniqueness of each token. # Tokenomics XYXYX has a total supply of 128 tokens. The supply has irreversibly decreased by 5.46% (from 128 to 121 tokens) after 7 XYXYX tokens were sent to the Ethereum burn address by [0xa47b...c579](https://etherscan.io/address/0xa47bea3bbfc9a9655e1cad064217d7eb0dcdc579). *** ### IDO XYXYX launched on the Ethereum Mainnet on February 23, 2024, through a Uniswap V3 LP. *** ### Allocations
Allocation%AmountAddress
Liquidity Pool90115 XYXYX0x79AE...90cC
Team5.57 XYXYX0xb40c...6814
Treasury4.56 XYXYX0x4ac9...96ad
*** {% hint style="info" %} See XYXYX Holders List [here](https://ethplorer.io/address/0x382e57ca8e4c4db9649884ca77b0a355692d14ac#pageTab=holders\&tab=tab-holders). Please note that Etherscan only counts holders of at least 1 full XYXYX, excluding the fractional holders. {% endhint %} # Xyxyx Issuer Nodes (XINs) ### Overview Xyxyx Issuer Nodes (XINs) are incorporated through [XYXYX](/protocol/xyxyx). XINs constitute a permissionless, decentralized network of nodes that powers the Xyxyx Launchpad. XIN operators are the only entities allowed to execute deployments on the Xyxyx Launchpad. Additionally, XINs provide access to the [Xyxyx API](https://developer.xyxyx.pro/). *** #### How to become an XIN operator
Node incorporation * XYXYX can be traded on Uniswap [here](https://app.uniswap.org/swap?inputCurrency=ETH\&outputCurrency=0x382E57cA8e4c4DB9649884ca77B0a355692D14AC) * Current [NP](#node-policy-np) is `1` XYXYX per XIN
Node connection **Xyxyx Launchpad** * Go to [xyxyx.pro/launchpad](https://www.xyxyx.pro/launchpad) and connect to the platform * It will be checked if your address holds the amount of XYXYX that is required to incorporate an XIN * See [Operator Network Status](#operator-network-status) **Xyxyx API** * See [Developer Documentation](https://developer.xyxyx.pro/)
*** ### Node Policy (NP) Node Policy (NP) is the policy that stipulates the amount of XYXYX required to incorporate an XIN. {% hint style="info" %} The current NP is `1` XYXYX per XIN, as defined by [XIP-1](https://vote.xyxyx.pro/#/proposal/0x2b1de3995cce075869c43914961e3a486d80ddcc21ae8065f29d254d7e4bfc7e). {% endhint %} #### Policy making NP is managed by the [Xyxyx DAO](/protocol/governance) via [Xyxyx Improvement Proposals (XIPs)](/protocol/governance/xyxyx-improvement-proposals-xips). Xyxyx DAO is free to manage the NP, meaning that the DAO can increase or decrease the amount of XYXYX required to incorporate an XIN. As XYXYX has 18 decimals, Xyxyx DAO can stipulate from 1 XYXYX to 0.000000000000000001 XYXYX to incorporate an XIN. Example: * If NP is 1 XYXYX per XIN = a cap of 121 XIN operators; * If NP is 0.1 XYXYX per XIN = a cap of 1,210 XIN operators; * If NP is 0.01 XYXYX per XIN = a cap of 12,100 XIN operators; * If NP is 0.001 XYXYX per XIN = a cap of 121,000 XIN operators; * If NP is 0.0001 XYXYX per XIN = a cap of 1,210,000 XIN operators; * If NP is 0.00001 XYXYX per XIN = a cap of 12,100,000 XIN operators, * And so on. *** ### Node Network #### Network Size XINs' network size can be measured based on the number of node operators participating in the network, which is measured based on the number of addresses owning the minimum amount of XYXYX that is required to incorporate an XIN. For example, if 30 addresses currently own at least 1 XYXYX and the current NP stipulates 1 XYXYX per XIN, it results in a network size of 30 node operators. Please note that when measuring XINs' network size, [the XYXYX/ETH LP address](https://etherscan.io/address/0x79ae08f81a8ffde94938d5c5f51259a8e02890cc), [the Treasury address](https://etherscan.io/address/0x4Ac9d175Cd5A4BE6D8A4D70C6A64E61de2BD96aD), [the token locker address](https://etherscan.io/address/0xdba68f07d1b7ca219f78ae8582c213d975c25caf), and [the Ethereum Burn address](https://etherscan.io/address/0x000000000000000000000000000000000000dead) must be excluded. *** #### Network Number of Nodes The network number of nodes is measured by the number of XIN operators and how many nodes these XIN operators own together; since anyone can permissionlessly own an XIN *cluster* (i.e., multiple nodes). For example, if there are 30 XIN operators that, together, own 65 nodes, the network has 65 nodes incorporated. Please note that when measuring XINs' network number of nodes, [the XYXYX/ETH LP address](https://etherscan.io/address/0x79ae08f81a8ffde94938d5c5f51259a8e02890cc), [the Treasury address](https://etherscan.io/address/0x4Ac9d175Cd5A4BE6D8A4D70C6A64E61de2BD96aD), [the token locker address](https://etherscan.io/address/0xdba68f07d1b7ca219f78ae8582c213d975c25caf), and [the Ethereum Burn address](https://etherscan.io/address/0x000000000000000000000000000000000000dead) must be excluded. *** #### Operator Network Power XIN operators can calculate their % power over the network by employing the equation below: $$ x = \frac{y}{z} \* 100 $$ * 𝑥 denotes *Operator Network Power,* 𝑦 denotes *Operator Number of Nodes*, and 𝑧 denotes *Network Number of Nodes.* *** #### Operator Network Participation XIN operators can calculate their % participation over the network by employing the equation below: $$ x = \frac{1}{z} \* 100 $$ * 𝑥 denotes *Operator Network Participation,* the `1` value denotes *Operator*, and 𝑧 denotes *Network Size.* *** #### Network Formation XINs' network formation is based on the XYXYX distribution, which is permissionless and decentralized. The network formation reflects the XYXYX market activity, rearranging paired to the token distribution. *** #### Operator Network Status The connection status of XIN operators in the network is displayed in the Xyxyx Launchpad's interfaces through two icons: * **Connected**
* **Not connected**
# XYHASH The XYXYX smart contract has a built-in hash function called XYHASH, which provides uniqueness to each token output. Unlike traditional hash functions that output a string of numbers and characters (e.g., SHA256), XYHASH generates outputs in the form of Hex color codes, utilizing the `tokenId` of each XYXYX as the input variable. For each combination of numbers that represents a `tokenId` — which is always unique for each token —, a unique combination of two Hex colors is produced as hashed output by the XYXYX smart contract. ```solidity function getColorComponentRed(uint256 value) internal pure returns (uint16) { return uint16((value >> 8) & 0xf); } function getColorComponentGreen(uint256 value) internal pure returns (uint16) { return uint16((value >> 4) & 0xf); } function getColorComponentBlue(uint256 value) internal pure returns (uint16) { return uint16(value & 0xf); } bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; function getColorHexCode(uint256 value) internal pure returns (string memory) { uint16 red = getColorComponentRed(value); uint16 green = getColorComponentGreen(value); uint16 blue = getColorComponentBlue(value); bytes memory buffer = new bytes(7); buffer[0] = "#"; buffer[1] = _HEX_SYMBOLS[red]; buffer[2] = _HEX_SYMBOLS[red]; buffer[3] = _HEX_SYMBOLS[green]; buffer[4] = _HEX_SYMBOLS[green]; buffer[5] = _HEX_SYMBOLS[blue]; buffer[6] = _HEX_SYMBOLS[blue]; return string(buffer); } function xyHash(string memory prefix, uint256 tokenId) private pure returns (uint256) { return uint256(keccak256(abi.encodePacked(prefix, tokenId))) % 4096; } function getColor1(uint256 tokenId) public pure returns (uint256) { return xyHash("1", tokenId); } function getColor2(uint256 tokenId) public pure returns (uint256) { return xyHash("2", tokenId); } ``` 1. **getColorComponentRed, getColorComponentGreen, getColorComponentBlue**: These three functions extract the red, green, and blue components of a color from a `uint256` value. This is achieved by bit-shifting the value to the right (`>>`) and applying a bitwise, and operation (`&`) with `0xf` (hexadecimal for 15) to isolate the last four bits. The bit-shifting distances (8 for red, 4 for green, and 0 for blue) position the bits of interest in the rightmost position to apply the mask (`0xf`). The result is cast to `uint16` and represents the color component value in the range of 0 to 15. * **Red Component**: Extracted by shifting the value 8 bits to the right and isolating the last four bits. * **Green Component**: Extracted by shifting the value 4 bits to the right and isolating the last four bits. * **Blue Component**: Extracted by directly isolating the last four bits of the value. 2. **\_HEX\_SYMBOLS**: A private constant byte array containing the hexadecimal symbols '0' to 'f'. This is used to map the numeric color component values (0-15) to their hexadecimal character representations. 3. **getColorHexCode**: This function uses the three color component functions to obtain the red, green, and blue values of a color, maps these values to their hexadecimal characters using the `_HEX_SYMBOLS` array, and constructs a hexadecimal color code string. The color code string starts with a "#" followed by two characters for each color component, doubling each character for simplicity (e.g., if the red component is `0xf`, it will be represented as "ff" in the string). 4. **xyHash**: A function that generates a hash value based on a given string prefix and a `uint256` `tokenId`. It uses the `keccak256` hash function on the concatenated string and `tokenId`, then takes the result modulo 4096 *(refers to the mathematical operation known as the "modulo" operation, which finds the remainder when one number is divided by another. In this context, after computing the hash function (likely producing a large integer as a result), the modulo operation is applied with 4096 as the divisor.).* This ensures a fixed range of possible outcomes, which is useful for generating predictable yet unique values for color determination. 5. **getColor1 and getColor2**: These public functions generate color values by calling `xyHash` with different string prefixes ("1" and "2", respectively), and the given `tokenId`. The resultant hash values can then be used to determine unique colors for each, potentially for use in generating or coloring tokens.

A sequence diagram illustrating the process from receiving a token ID to generating a color Hex code executed by XYHASH

# Governance {% hint style="info" %} **PUBLIC PREVIEW DOCUMENT** This document is currently in **public preview** and may change significantly as feedback is captured from the community. {% endhint %} ### Overview Xyxyx Protocol is managed by the Xyxyx DAO, a decentralized organization of XYXYX tokenholders responsible for shaping the protocol's future. The DAO enables a community-driven approach to decision-making and management, empowering XYXYX tokenholders to influence the development and operation of the Xyxyx Protocol. Through a collective voting mechanism and a consensus-building process, Xyxyx DAO ensures that the Xyxyx Protocol evolves in alignment with the interests and inputs of XYXYX tokenholders, fostering a decentralized, community-centric governance model. *** ### Governance Framework Xyxyx DAO is responsible for governing the Xyxyx Protocol, which includes (1) proposing changes and new features to the protocol; (2) dictating the policy for accessing the Xyxyx Launchpad; (3) dictating the Treasury, and (4) improving governance itself. The protocol governance is structured upon two types of governance proposals:
Xyxyx Implementation Proposals (XIPs) Proposals to change or implement a new feature to the protocol. [Learn more](/protocol/governance/xyxyx-improvement-proposals-xips)
Treasury Management Proposals (TMPs) Proposals to execute relevant actions involving management of the Treasury. [Learn more](/protocol/governance/treasury-management-proposals-tmps)
*** ### Governance Process XIPs and TMPs must follow a two-stage process: 1. A public discussion post on the Governance Forum 2. A voting poll via Snapshot #### Governance Forum Proposals must start with a post on the Governance Forum. Feedback from the community will materially increase the chances of a successful and well-aligned governance proposal. * The appropriate space to gauge interest in XIPs is the [Proposals](https://forum.xyxyx.pro/c/proposals/7) topic, which is dedicated to proposing XIPs for public discussion in the Governance Forum. * For TMPs, the appropriate space to gauge the interest of the community is the [Treasury](https://forum.xyxyx.pro/c/treasury/10) topic, which is dedicated to proposing TMPs for public forum discussions. * Anyone can post and contribute to discussions on the Governance Forum. #### Snapshot Once a public discussion has been conducted around an XIP or a TMP in the Governance Forum, the author must issue the proposal for a voting poll via Snapshot. * For XIPs, the author must use the [XIP template](/protocol/governance/xyxyx-improvement-proposals-xips#xip-template) to construct the proposal. * For TMPs, the author must use the [TMP template](/protocol/governance/treasury-management-proposals-tmps#tmp-template) to construct the proposal. *** ### Governance Parameters
Proposal Submission Threshold: 1 XYXYX To submit a proposal, the user must have at least 1 XYXYX.
Proposal Voting Threshold: 0.00001 XYXYX Any user who owns at least 0.00001 XYXYX can participate in voting for any proposal. Voting is calculated by a weighted voting system, where voting power is proportional to the amount of XYXYX tokens cast, i.e., 0.5 XYXYX = 0.41% of voting power; 1 XYXYX = 0.82% of voting power; 2 XYXYX = 1.64% of voting power, and so on.
Voting Period: 10 days Once the voting period is live, the DAO members will be able to cast votes during this period.
Quorum Threshold: 25% of total supply When the voting period ends, it's checked if the number of 'Yes' votes exceeds the protocol's **quorum threshold**. Xyxyx DAO requires 25% of XYXYX's total supply (30.25 of 121 XYXYX) to vote 'in support' to reach quorum (i.e., at least 30.25 XYXYX need to cast 'Yes' votes to the quorum be reached and subsequently, if having majority support, a proposal be considered passed).
Timelock Queue: 3 days After the **voting period**, proposals with a majority support are considered passed and placed into a **timelock queue** which delays proposal execution, giving a period of time for users to adapt to the changes that will be implemented in the protocol.
*** ### Governance Infrastructure * **Forum**: [forum.xyxyx.pro](https://forum.xyxyx.pro/) * **Snapshot**: [vote.xyxyx.pro](https://vote.xyxyx.pro/#/) * **ENS**: [xyxyxdao.eth](https://app.ens.domains/xyxyxdao.eth) {% hint style="info" %} Xyxyx team uses the address [0xB42d...B7a1](https://etherscan.io/address/0xB42dD0878219c3fC356ABe8F7c0800b80147B7a1) as a governance node for issuing proposals on Snapshot. 0xB42d...B7a1 is whitelisted as author, however, the address has no voting power. No more addresses can be whitelisted. {% endhint %} # Xyxyx Improvement Proposals (XIPs) ### Overview Xyxyx Improvement Proposals (XIPs) are governance proposals that aim to (1) propose changes and new features to the protocol; (2) dictate the policy for accessing the Xyxyx Launchpad; and (3) improve governance itself. *** ### Template The author must use the following template when writing an XIP for voting on Snapshot: {% code overflow="wrap" %} ``` --- [XIP-#] --- ## Abstract Two or three sentences that summarize the XIP. ## Motivation A statement on why the Xyxyx community should implement the XIP. ## Motivation Provide an explanation for why this change is necessary. ## Rationale An explanation of how the XIP aligns with the Xyxyx community's mission and guiding values. ## Key Terms Definitions of any terms within the proposal that are unique to the proposal, new to the Xyxyx community, and/or industry-specific. This section is optional, but recommended. ## Specifications A detailed breakdown of the platforms and technologies that will be used. This is where you can elaborate on the "why" of your design decisions. You can also use this section to describe alternate designs that were considered and related work, e.g. how similar specifications have been successfully (or unsuccessfully) implemented in other chains or languages. ## Steps to Implement The steps to implement the XIP, including associated costs, manpower, and other resources for each step where applicable. XIPs that involve transactions with third parties will need to ensure that applicable legal documentation and procedures are also included. ## Timeline Relevant timing details, including but not limited to start date, milestones, and completion dates. ## Overall Cost The total cost to implement the XIP. The overall cost section should include a breakdown of the total cost of the XIP, including any associated costs for each step where applicable. Consider both fixed costs and recurring costs. ``` {% endcode %} *** ### Preamble XIP drafts on the Governance Forum must include a preamble section at the head of the post using the following template: ``` XIP#: <number> Title: <title> Author(s): <author> Contributors: <contributors> Status: <status> Date Proposed: <yy-mm-dd> Date Ratified: <yy-mm-dd> Forum URL: <URL> Ratification Poll URL: <URL> ``` #### Status * **Draft**: This XIP is a work in progress. * **Proposed**: This XIP is issued for voting. * **Accepted**: This XIP has passed and must be executed. * **Rejected**: This XIP has failed to reach community consensus. * **Implemented**: This XIP has been implemented. # Treasury Management Proposals (TMPs) ### Overview Treasury Management Proposals (TMPs) are governance proposals that aim to execute relevant actions involving management of the Treasury. *** ### Template The author must use the following template when writing a TMP for voting on Snapshot: {% code overflow="wrap" %} ``` --- [TMP-#] <title> --- ## Abstract Two or three sentences that summarize the TMP. ## Motivation A statement on why the Xyxyx community should implement the XIP. ## Rationale An explanation of how the TMP aligns with the Xyxyx community's mission and guiding values. ## Key Terms Definitions of any terms within the proposal that are unique to the proposal, new to the Xyxyx community, and/or industry-specific. This section is optional, but recommended. ## Specifications A detailed breakdown of the specifications of the proposal. This is where you can elaborate on the "why" of your terms decisions. ## Steps to Implement The steps to implement the TMP, including associated costs, manpower, and other resources for each step where applicable. ## Timeline Relevant timing details, including but not limited to start date and completion dates. ## Overall Cost The total cost to execute the TMP. The overall cost section should include a breakdown of the total cost of the TMP, including any associated costs for each step where applicable. Consider both fixed costs and recurring costs. ``` {% endcode %} *** ### Preamble TMP drafts on the Governance Forum must include a preamble section at the head of the post using the following template: ``` TMP#: <number> Title: <title> Author(s): <author> Contributors: <contributors> Status: <status> Date Proposed: <yy-mm-dd> Date Ratified: <yy-mm-dd> Forum URL: <URL> Ratification Poll URL: <URL> ``` #### Status * **Draft**: This TMP is a work in progress. * **Proposed**: This TMP is issued for voting. * **Accepted**: This TMP has passed and must be executed. * **Rejected**: This TMP has failed to reach community consensus. * **Executed**: This TMP has been executed. # Resubmit a proposal Learn how to resubmit a proposal that was previously rejected or did not reach quorum. #### Step 1: Review the feedback from the previous proposal[​](https://docs.arbitrum.foundation/how-tos/resubmit-dao-proposal#step-1-review-the-feedback-from-the-previous-proposal) <a href="#step-1-review-the-feedback-from-the-previous-proposal" id="step-1-review-the-feedback-from-the-previous-proposal"></a> Review the feedback from the previous proposal and try to identify any common concerns or objections that were raised by the community. Align with the community on the best way to address these concerns and incorporate them into your proposal. *** #### Step 2: Draft a revision[​](https://docs.arbitrum.foundation/how-tos/resubmit-dao-proposal#step-2-draft-a-revision) <a href="#step-2-draft-a-revision" id="step-2-draft-a-revision"></a> Incorporate the community's feedback into a revised proposal. Consider using your original proposal's forum thread to draft this revision. Ensure that you incorporate any new information that may have become available since the original proposal was submitted. *** #### Step 3: Resubmit the proposal[​](https://docs.arbitrum.foundation/how-tos/resubmit-dao-proposal#step-3-resubmit-the-proposal) <a href="#step-3-resubmit-the-proposal" id="step-3-resubmit-the-proposal"></a> Treat your revised proposal as a brand-new proposal. Begin by conducting a new discussion on the governance forum. Pay close attention to the guidance within the proposal structure section of this procedure; you'll want to include additional information that explicitly addresses the concerns that were raised during the previous submission. *** If your proposal is rejected multiple times, it may be best to reconsider the proposal altogether or to engage more extensively with the community to gather feedback and build support. Resubmitting a proposal is an iterative process that requires patience, persistence, and an open mind. By working closely with the community to capture and integrate feedback, you can increase your chances of getting your proposal passed. # Treasury Coming soon ### Overview Treasury is a protocol-owned [XYXYX](/protocol/xyxyx) reserve, which is dictated by the [Xyxyx DAO](/protocol/governance). The Treasury was initially funded with an allocation of 6 XYXYX. Xyxyx charges a 1% fee over the sell-side transactions incurred in the XYXYX/ETH LP, which is deployed and owned by the Xyxyx Protocol — and the only market available for XYXYX. This 1% fee is charged as XYXYX and entirely collected by the Treasury. *** ### Financial Statement * Treasury Balance Sheet: 22.45 XYXYX\* <table><thead><tr><th width="204">AMOUNT</th><th>ORIGIN</th></tr></thead><tbody><tr><td>6 XYXYX</td><td><ul><li>Treasury allocation from XYXYX tokenomics</li><li>Locked and held at UNCX - pending withdrawal by Treasury</li></ul></td></tr><tr><td>7 XYXYX</td><td><ul><li>Reallocated from Team allocation from XYXYX tokenomics</li><li>Locked and held at UNCX until March 2025</li></ul></td></tr><tr><td>4 XYXYX</td><td><ul><li>Allocated by <a href="https://etherscan.io/address/0xa47bea3bbfc9a9655e1cad064217d7eb0dcdc579">0xa47b...c579</a></li><li>Held at Treasury's address (<a href="https://etherscan.io/address/0x4Ac9d175Cd5A4BE6D8A4D70C6A64E61de2BD96aD">0x4Ac9...96aD</a>)</li></ul></td></tr><tr><td>5.45 XYXYX</td><td><ul><li>Sell-side fees collected by XYXYX/ETH LP since February 23rd, 2024</li><li>Held at UNCX locker - pending withdrawal by Treasury</li></ul></td></tr></tbody></table> *\*As of January 15th, 2025* # Ecosystem Text-based tokenization is a fertile and vast ground for developing applications that propose new paradigms. As we continue to expand Xyxyx as the foundational layer for text-based tokenization on Ethereum, we are formalizing our commitment to developers building mission-critical applications on Xyxyx. Through [Build with Xyxyx](https://www.xyxyx.pro/build), we offer structured, end-to-end guidance for those working with the [Xyxyx API](/products-and-services/api) and text-based tokenization. *** ### Build with Xyxyx Build with Xyxyx is an open-access developer support initiative. It is envisioned to ensure that teams — from early-stage prototypes to production-grade applications — have direct access to the resources, advisory, and technical insight needed to build on Xyxyx. Through this program, developers can: * Access tailored technical support for integrating with the Xyxyx infrastructure; * Receive guidance on architectural best practices for text-based tokenization; * Collaborate with the Xyxyx team on protocol design; * Explore advanced use cases of Xyxyx's text-based tokenization infrastructure stack, * And more. #### Get started Build with Xyxyx is a direct line of collaboration between builders and the Xyxyx team. To express interest, developers are invited to fill out a short form at [xyxyx.pro/build](https://www.xyxyx.pro/build). The form provides an opportunity to outline the nature of the project, its technical focus, and specific areas where collaboration or support may be beneficial. We will review submissions and follow up accordingly. # Addresses ### Mainnet #### Ethereum Mainnet <table><thead><tr><th width="250">Name</th><th>Address</th><th data-hidden></th></tr></thead><tbody><tr><td>Launchpad Reference Implementation Contract</td><td><a href="https://etherscan.io/address/0xec3a52a2869195baf91e9f3c0a864247b0cd419c">0xec3a52a2869195baf91e9f3c0a864247b0cd419c</a></td><td></td></tr><tr><td>Xyxyx: Deployer</td><td><a href="https://etherscan.io/address/0xB40cB3c9d356eB10be1379A5A9cA75e94CD76814">0xB40cB3c9d356eB10be1379A5A9cA75e94CD76814</a></td><td></td></tr><tr><td>XYXYX</td><td><a href="https://etherscan.io/address/0x382E57cA8e4c4DB9649884ca77B0a355692D14AC">0x382E57cA8e4c4DB9649884ca77B0a355692D14AC</a></td><td></td></tr><tr><td>Treasury</td><td><a href="https://etherscan.io/address/0x4Ac9d175Cd5A4BE6D8A4D70C6A64E61de2BD96aD">0x4Ac9d175Cd5A4BE6D8A4D70C6A64E61de2BD96aD</a></td><td></td></tr></tbody></table> #### OP Mainnet <table><thead><tr><th width="250">Name</th><th>Address</th><th data-hidden></th></tr></thead><tbody><tr><td>Launchpad Reference Implementation Contract</td><td><a href="https://optimistic.etherscan.io/address/0x382e57ca8e4c4db9649884ca77b0a355692d14ac">0x382e57ca8e4c4db9649884ca77b0a355692d14ac</a></td><td></td></tr><tr><td>Xyxyx: Deployer</td><td><a href="https://optimistic.etherscan.io/address/0xb40cb3c9d356eb10be1379a5a9ca75e94cd76814">0xB40cB3c9d356eB10be1379A5A9cA75e94CD76814</a></td><td></td></tr></tbody></table> #### Base Mainnet <table><thead><tr><th width="250">Name</th><th>Address</th><th data-hidden></th></tr></thead><tbody><tr><td>Launchpad Reference Implementation Contract</td><td><a href="https://basescan.org/address/0x382e57ca8e4c4db9649884ca77b0a355692d14ac">0x382e57ca8e4c4db9649884ca77b0a355692d14ac</a></td><td></td></tr><tr><td>Xyxyx: Deployer</td><td><a href="https://basescan.org/address/0xb40cb3c9d356eb10be1379a5a9ca75e94cd76814">0xB40cB3c9d356eB10be1379A5A9cA75e94CD76814</a></td><td></td></tr></tbody></table> #### Arbitrum One <table><thead><tr><th width="250">Name</th><th>Address</th><th data-hidden></th></tr></thead><tbody><tr><td>Launchpad Reference Implementation Contract</td><td><a href="https://arbiscan.io/address/0x382e57ca8e4c4db9649884ca77b0a355692d14ac">0x382E57cA8e4c4DB9649884ca77B0a355692D14AC</a></td><td></td></tr><tr><td>Xyxyx: Deployer</td><td><a href="https://arbiscan.io/address/0xb40cb3c9d356eb10be1379a5a9ca75e94cd76814">0xb40cb3c9d356eb10be1379a5a9ca75e94cd76814</a></td><td></td></tr></tbody></table> *** ### Testnets #### Ethereum Sepolia <table><thead><tr><th width="250">Name</th><th>Address</th><th data-hidden></th></tr></thead><tbody><tr><td>Launchpad Reference Implementation Contract</td><td><a href="https://sepolia.etherscan.io/address/0xf34aa9a2d6dcd7f8f800667003bbcc4a6cfe55e0">0xf34aa9a2d6dcd7f8f800667003bbcc4a6cfe55e0</a></td><td></td></tr><tr><td>Xyxyx: Deployer</td><td><a href="https://sepolia.etherscan.io/address/0xb40cb3c9d356eb10be1379a5a9ca75e94cd76814">0xB40cB3c9d356eB10be1379A5A9cA75e94CD76814</a></td><td></td></tr></tbody></table> #### OP Sepolia <table><thead><tr><th width="250">Name</th><th>Address</th><th data-hidden></th></tr></thead><tbody><tr><td>Launchpad Reference Implementation Contract</td><td><a href="https://sepolia-optimism.etherscan.io/address/0x382e57ca8e4c4db9649884ca77b0a355692d14ac">0x382E57cA8e4c4DB9649884ca77B0a355692D14AC</a></td><td></td></tr><tr><td>Xyxyx: Deployer</td><td><a href="https://sepolia-optimism.etherscan.io/address/0x382e57ca8e4c4db9649884ca77b0a355692d14ac">0xB40cB3c9d356eB10be1379A5A9cA75e94CD76814</a></td><td></td></tr></tbody></table> #### Base Sepolia <table><thead><tr><th width="250">Name</th><th>Address</th><th data-hidden></th></tr></thead><tbody><tr><td>Launchpad Reference Implementation Contract</td><td><a href="https://sepolia.basescan.org/address/0x382e57ca8e4c4db9649884ca77b0a355692d14ac">0x382e57ca8e4c4db9649884ca77b0a355692d14</a></td><td></td></tr><tr><td>Xyxyx: Deployer</td><td><a href="https://sepolia.basescan.org/address/0xb40cb3c9d356eb10be1379a5a9ca75e94cd76814">0xb40cb3c9d356eb10be1379a5a9ca75e94cd76814</a></td><td></td></tr></tbody></table> #### Arbitrum Sepolia <table><thead><tr><th width="250">Name</th><th>Address</th><th data-hidden></th></tr></thead><tbody><tr><td>Launchpad Reference Implementation Contract</td><td><a href="https://sepolia.arbiscan.io/address/0x382e57ca8e4c4db9649884ca77b0a355692d14ac">0x382e57ca8e4c4db9649884ca77b0a355692d14ac</a></td><td></td></tr><tr><td>Xyxyx: Deployer</td><td><a href="https://sepolia.arbiscan.io/address/0xb40cb3c9d356eb10be1379a5a9ca75e94cd76814">0xB40cB3c9d356eB10be1379A5A9cA75e94CD76814</a></td><td></td></tr></tbody></table> # Links [Website](https://docs.xyxyx.pro/miscellaneous/www.xyxyx.pro), [Blog](https://mirror.xyz/0xB42dD0878219c3fC356ABe8F7c0800b80147B7a1), [Developer Docs](https://developer.xyxyx.pro/), [Twitter](https://x.com/xyxyxpro), [Telegram](https://t.me/xyxyx404), [GitHub](https://github.com/xyxyxpro), [Forum](https://forum.xyxyx.pro/), [Snapshot](https://vote.xyxyx.pro/#/) # Brand Assets #### Xyxyx Logo White <figure><img src="https://1171814187-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEphDMF9wXmQh2rIdzUdc%2Fuploads%2FiDg6kIHFDgaU0TLBMGjZ%2Fxyxyx-logotype-white.png?alt=media&token=56ba4f3b-9ede-4561-aae3-ff4b795c4c47" alt="" width="375"><figcaption></figcaption></figure> *** #### Xyxyx Logo Black <figure><img src="https://1171814187-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEphDMF9wXmQh2rIdzUdc%2Fuploads%2FewjdUxIfGvlmSMAasRSx%2Fxyxyx-logotype-black.png?alt=media&token=0c73b065-0071-4121-99b6-b7f1cf109127" alt="" width="375"><figcaption></figcaption></figure> *** #### Xyxyx Logomark White <figure><img src="https://1171814187-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEphDMF9wXmQh2rIdzUdc%2Fuploads%2FNtqkgnbNjzPfhDl3ghch%2Fxyxyx-logo-white.png?alt=media&token=d811b8c0-d337-4214-a9ca-5c67038a5d1c" alt="" width="188"><figcaption></figcaption></figure> *** #### Xyxyx Logomark Black <figure><img src="https://1171814187-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEphDMF9wXmQh2rIdzUdc%2Fuploads%2Fywfk2Vt8Jex2c1VC5pF0%2Fxyxyx-logo-black.png?alt=media&token=267bc85f-3604-46bf-b3ae-4ec06d3886d9" alt="" width="188"><figcaption></figcaption></figure> *** #### XYXYX Token Glyph <figure><img src="https://1171814187-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FEphDMF9wXmQh2rIdzUdc%2Fuploads%2Fsr9zm2QaDsDDLy4JtrrF%2Fxyxyx-token-glyph.png?alt=media&token=4b552506-0cbc-4562-ae09-9bc982923573" alt="" width="188"><figcaption></figcaption></figure> *** **Download Xyxyx Press Kit** {% file src="/files/IcXmGWJjVX41z3Quld8X" %} **Things to avoid when using Xyxyx logos:** * Please do not alter the logos in any way * Use enough spacing around the logos * We encourage you to select the black or white version which maximizes contrast, rather than custom colors *** > For anything else, please contact us at <info@xyxyx.pro>.