2022:

Inception. Internal building. OTC trading.

2023:

Q1: KiiChain Dev Net.

Q3: KIIEX Beta was launched, testing trading and payments in mainnet in a whitelisted environment (over $50m in total volume). Achieved positive EBIDTA and net margin.

2024:

Q2: KIIEX left beta and launched mainnet with multi-varied APIs and a suite of other features. KIIEX onboarded over 200 enterprise clients with access to over 200k in users.

2025:

Q1 & Q2:

• Public sale, listing and mainnet.

• PayFi module integration with mainnet.

• KIIEX version 2.0 will be released with new UI/UX and third party ramp features.

• KIIDEX integration into KIIEX with listing of RWA products.

• DASP license in El Salvador for both KIIEX and KiiChain.

• IBC and Wasm upgrades.

• ICS module with dual staking.

Q3:

• PayFi module fiat rail integrations and expansions. Connect to local payment gateways in target markets.

• Kii RWA protocol dApp that lets users manage cross-chain transfers of their RWA tokens.

• KIIEX API integrations for 30+ countries.

• KIIEX Debit and Credit cards (with lend-borrow financing).

Q4:

• Payfi financing protocol (ecosystem partnership) integrated with the Payfi module register profiles to extend credit to web2 and web3 companies and users.

• On-chain invoice factoring and financing.

• SVM module.

KIIEX Trading and Processing Fees

By inaugurating our proprietary centralized exchange platform, we're revolutionizing the remittance and payment experience for users. This nexus of cryptocurrency trading ensures seamless transactions, all while fostering an environment of growth and financial prosperity. KIIEX leads the market for cash-in/cash-out options in Latam.

DeFi Wallet Trading Fees

Our homegrown multi-currency decentralized wallet offers users a secure haven for their assets. Nominal trading and transfer fees not only ensure affordability for our users but also serve as a sustainable revenue stream for the KII ecosystem. This wallet, attuned to user needs, exemplifies the blend of security, functionality, and cost-efficiency, becoming an indispensable tool for every crypto enthusiast.

KiiView Fees

Users will pay for block time in native token to run the AI models. A percentage of those fees will be collected by Kii Global.

DeFi Commissions

5% of total supply is for posting liquidity to DEX operations, and after the public sale, that 5% will be matched in liquidity on the other side of the trade. These trades will produce revenue for the holding company.

Fees from Integrations

Our footprint in the blockchain space hasn't gone unnoticed. By integrating KII's robust ecosystem into conventional fintech enterprises, we've forged a revenue model wherein we glean a slice of every transaction made through our infrastructural offerings.

Secondary Suite of Products

Apart from the main revenue streams, Kii Global roadmap entails launching a suite of banking-as-a-service products like cold storage processing cards which will further produce earnings for the company.

Coin Details

No minting or burning.

Tokenization of Commodities (RWA)

Commodities are among the most valuable and traded goods in the world with major reserves being mined and developed in emerging countries. Local companies can now tokenize their commodities and contracts, pricing them in Kii or a native asset to their project, and create instant liquidity on a global scale.

Tokenization of Products (RWA)

Imported and exported goods are one of the major drivers of GDP within Latin America and emerging economies. Many multinational companies in the region struggle to process funds and manage liquidity reserves. These products can be tokenized and transacted on the blockchain for users to transact with these goods, and for companies to better manage their reserves.

Tokenization of Real Estate (RWA)

Asset fractionalization and ownership is becoming more imperative than ever before in markets with wealth fragmentation, high inflation and high interest rates. Real estate and asset infrastructure fractionalization allows users to own yield bearing, inflation protected, assets that cannot be owned by these users in whole. By democratizing the ownership process, liquidity can extend to other markets and users who would not otherwise have access prior.

Tokenization of Debt and Equities (RWA)

Public equities, debt instruments, or exchange traded funds that are trading on traditional exchanges can be tokenized to expand, democratize and fractionalize their access cross-border, to individuals who do not have access to these opportunities.

DeFi Lending and Borrowing for Open Credit System

Credit is a huge issue in developing countries with strict underwriting standards, toxic level interest rates and lack of available capital. DeFi lending will provide secure ways for users in developed countries to extend safe credit terms to participants in emerging markets.

Yield Farming

High yield opportunities are plentiful in Latam, and can help generate this productive yield for yield farming aggregators to offer to lenders with liquidity.

Payment settlement and remittances

Upon block number 1, KiiChain can process 12,000 transactions per second (TPS) and can scale within the Cosmos ecosystem with IBC. Currently the Cosmos community is collectively synced to process ~500,000 TPS, and depending on the inclusion of future layer 1s, processing can increase to an infinite number. Transaction fees in KiiChain are a fraction of a peso and settlement is instantaneous. Users can seamlessly remit funds to any wallet in the world.

Spot and Forward Settlement

The B2B remittance market transacts over $600 billion USD. These importers and exporters either win or lose on spot or forward contract settlements. By each counterparty posting liquidity via a smart contract on the blockchain, users can eliminate losses by sharing in any FX swings.

Inflation Protection & IBC

KiiChain has a fixed supply 1,800,000,000 KII with no minting or burning of tokens. Therefore, the total amount can never be inflated. In fact, on the contract, 5% of cash flow from operations of Kii Global will be reverted back to purchasing Kii and replenishing the staking and rewards pool.

Additionally, KiiChain integrates cross-chain bridging software that allows dollar-denominated or alternative "inflation protection" assets and stablecoins to be deployed natively to the network.

What is KiiChain?

KiiChain is a layer 1 blockchain built with the Cosmos SDK. It blends EVM compatibility with multi-chain connectivity to create a network that is highly interoperable, scalable and easy to use. Its design purpose is to onboard the next generation of developers in emerging markets who are building the best use-cases for real-world users.

Cosmos SDK

Comet BFT & Tendermint Core

Proof-of-Stake

KiiChain is a Proof-of-Stake blockchain. PoS selects validators based on the number of tokens they hold and are willing to "stake" as collateral for servicing and securing the network. Delegators, or individual "stakers", can delegate their tokens to any specific validator that meets the requirements.

Kii RWA Protocol

The Kii RWA Protocol sets standardization of Real World Asset (RWA) tokenization through the T-REX (Token for Regulated EXchanges) protocol using CosmWasm smart contracts on KiiChain that are simultaneously mirrored to ERC tokens. The T-REX protocol is designed for compliant issuance and management of security tokens on blockchain networks. Apart from token standards, the protocol defines on-chain KYC, KYB and asset verification. The Kii RWA protocol on KiiChain is creating an interoperable unified liquidity layer for RWA tokens.

Kii Payfi Module

The Kii PayFi Module is a gas-optimized payment system for merchant transactions with specialized fee handling along with a Paymaster System to grant gas funds for DeFi actions via protocols. The module is developed for both web3 and web2 companies to incentivize the migration of their revenue and payment models to on-chain functions. Included in the module, is a Defi protocol that sets standards for TVL based loans, collateral management, interest models, and liquidity systems. Advanced features include revenue lending, invoicing financing, payment scheduling and TVL based credit card financing through community Payfi pools. This module is still in development and will be deployed in the coming weeks.

Mirrored EVM Module

The Sei EVM module allows for mirrored EVM compatibility and for smart contracts to be deployed in Solidity to the network. This means it can run all existing Ethereum dApps and smart contracts without needing any changes. It achieves this with a high-performance Ethereum Virtual Machine (EVM) that is optimized for speed and reliability. Essentially, Sei EVM runs an Ethereum-compatible virtual machine side chain that mirrors address balances between EVM and Cosmwasm tokens. Thanks to its modular, plugin-based design, it allows any host blockchain to execute Ethereum transactions and smart contracts.

IBC

Tokenization of RWA for Interoperability

Emerging markets historically suffer from high inflation, high interest rates, and less access to institutional lending. Tokenization of RWA is focused on solving traditional and emerging use cases:

1. Accessibility via Fractional Ownership: Emerging markets often lack the infrastructure for widespread investment opportunities. Tokenization enables fractional ownership, allowing investors to buy small portions of high-value assets. This makes investing accessible to a broader range of individuals who may not have the capital to buy entire assets.

2. Liquidity: Traditional real estate and other asset investments in emerging markets can be illiquid, with long holding periods. Tokenization allows for easier trading of these assets on secondary markets, enhancing liquidity and increasing yield from said assets.

3. Asset Fractionalization: In emerging markets where large assets such as real estate or infrastructure projects are typically owned by the wealthy. Tokenization enables these assets to be divided into smaller, more manageable units that can democratize access and stimulate economic growth by broadening ownership to individuals who cannot afford to purchase an entire asset or property.

4. Lower Costs: Exportation of commodities suffer from saturated Intermediaries that leave the producers with low margins. Tokenization can streamline the purchase and/or investment process, reducing transaction and trade costs.

5. Global Access: tokenized assets can be traded globally, allowing investors from anywhere in the world to participate in emerging market opportunities. RWA dApps seek access to Latin America markets but don't have the resources to bridge to reputable parties in the region.

6. Transparency: tokenizing assets on the public ledger can help mitigate certain risks around unclaimed or disputed land.

7. Compliance and Regulation: Tokenization platforms can integrate compliance mechanisms directly into smart contracts, ensuring that transactions adhere to relevant regulations, and protect investor rights.

Access to Institutional Liquidity & Credit

50% of individuals in emerging markets are underbanked and have extremely limited access to credit terms. The other 50% struggle with high banking costs and interest rates. Kii Global layer 1 with infrastructure for DeFi lending options mixed with the liquidity settlements of its centralized exchange is solving these problems.

Through bridging the capital disparities between developed and emerging economies, the Kii ecosystem will support a wide range of DeFi lending protocols tailored for emerging markets in parallel with KIIEX’s open liquidity to centralized applications.

Gas Fee Scalability for Micro-Payments

Scaling issues exist in current blockchain infrastructure because the amount of transactions processed in seconds is limited to total processing power. For example, Ethereum 2.0 can process roughly 30 transactions per second, therefore, it has to rely on sharding and rollups to scale horizontally and keep transactions flowing at minimal costs. High gas fees on Ethereum ($5 - $20 USD nominal) have prevented wide scale adoption among emerging markets. The majority of adoption thus far has been driven to more low cost gas networks like Tron. However, these networks are becoming more and more congested and the need for a more robust, structured decentralized solution is evident.

Cosmos’ CometBFT can process roughly 10,000 transactions per second and is predesigned within the Inter-Blockchain Communication Pool (IBC). IBC works in conjunction with other layer 1s in the cosmos community to process transactions and keep gas fees minimal, forever.

User Friendly Tokenization

Cosmos based blockchains are built to deploy smart contracts written in Rust and deployed via CosmWasm. Although Rust is an advanced language of code with its benefits, there is a lack of real world developers who understand Rust, and companies who are looking to deploy their contracts with that language.

KiiChain has coded in the popular Solidity language for building and launching smart contracts, making KiiChain EVM compatible. Users can easily deploy their smart contracts, already written in Solidity, into the KiiChain. Kii Global has built an in-house dedicated team to help deploy user’s smart contracts within the blockchain. Companies looking for assistance on how to build smart contracts can rely on Kii Global developers for support and assistance when writing and deploying code.

The Best Cash Settlements in Latin America (LatAm)

Mainstream remittance and payment providers, tethered to archaic banking systems like ACH and SWIFT, grapple with inefficiencies, tardiness and inflated costs. Their modern counterparts, built on decentralized ledger tech, often falter at the “last mile”, rendering their P2P solutions uneconomical.

Kii Global ecosystem offers a much better on-ramp and off-ramp than any other provider in LatAm. Typical on and off-ramp services have limits, delays, and generally are not a reliable way to onboard into crypto or to off-ramp into fiat. KIIEX is able to utilize the local financial infrastructure, because they have built relationships with the local banks, which makes their services low cost, reliable, and without long delays. A spotlight feature of the exchange is its emphasis on "last mile delivery," addressing the importance of deep liquidity pairs against local fiat and the efficient verticalization of its on/off ramp rails for less than 1% cost. This infrastructure helps onboard more web2 users into web3.

An Equitable Ecosystem Built for Latam

The Kii token and KiiChain gives a chance for Latam locals to participate in an ecosystem built just for them, and one they can own a piece of. Users can earn a return on their KII by staking it through validator nodes, and rewards are replenished with 5% of Kii Global cash flow. This gives every Latam person an opportunity to take part of a community and a company with a vision of equitable justice for all.

A Compliant Ecosystem

KII is not at risk of clashing with the local government and banks, because the KII team has done the hard work of educating and building relationships with top banks and government officials in Latam. While most traditional financial institutions have a stigma as well as a lack of knowledge about crypto, KII is paving the way by building the infrastructure needed to offer frictionless cash settlement services. The KII team is a shining example of what right looks like, when it comes to compliance.

1. KIIEX Benefits: KII holders will have reduced trading fees and cash-in/cash-out rates within the ecosystem. Users who remit funds in KII will have priority to liquidity and rates, especially within our ecosystem of partners.

2. KIIEX Incentives: KII will be used to create incentives for on-chain PayFi liquidity pools, designed specially to incentivize stablecoin liquidity when creating pools on the less demanded side of the trade. (ie: USDT / COP – higher need for COP liquidity than USDT liquidity, therefore those that create COP liquidity pools will receive KII incentives and greater spreads).

3. Payment for the use of the KiiChain RWA protocol: Payment for use of the RWA protocol and “unified liquidity” swaps to over 100+ networks will be in KII token relative to bps on total AUM of for permissioned tokens. Example: 10bps of the nominal asset value paid in KII from the liquidity sourced from an RWA purchase.

4. Pricing of Assets on KIIEX: Tokenized commodities and products can be priced in KII to create instant/easier liquidity in our hybrid CEX/DEX from native liquidity pools.

5. Collateral: KII will be used as a collateral on DeFi apps, liquid staking, lending, and futures settlement.

6. Staking: KII is required for validators and delegators to participate in the network. KII is the only token eligible for validating and delegating in KiiChain.

7. Rewards: KII is rewarded to validators and delegators for their service to the network.

8. Gas fees: KII is used for transaction fees. All transactions such as deployment of new smart contracts, creation of user accounts, or token transfer, require the payer to pay transaction fees in KII.

9. Governance: KII will be used for voting on future protocol and ecosystem development once the blockchain migrates to open governance.

Why KII?

While the cryptocurrency space is saturated with a myriad of options, Kii Global distinguishes itself through its profound commitment to societal betterment. Beyond the technical marvels and financial prospects, KiiChain's ethos is rooted in fostering an accessible, and inclusive financial landscape, especially for the Latino community.

Currently, 50% of citizens in developing countries are unbanked, or underbanked. The main reason: their income isn’t sufficient enough to pay for the monthly costs associated with traditional financial services. As a result, these users, and many small businesses associated, lack access to basic financial services and credit lines.

As the world rapidly pivots to a decentralized financial paradigm, Kii Global envisions itself at the forefront - not merely as a passive participant but as an active change-maker. By continually iterating on its offerings, forging meaningful partnerships, and staying attuned to the real-world needs of its users, Kii Global is not just building a blockchain; it's crafting the future of finance by combining zero-fixed cost solutions with problem-solving web3 applications.

At the heart of it all, Kii Global is more than just a blockchain company. It's a beacon of hope, a promise of a brighter financial future, and a testament to what's possible when innovation meets empathy. Our main goal: create a systemic shift in the middle class in emerging markets.

About KII

A lot has transpired since Satoshi's whitepaper announcing the arrival of Bitcoin in 2008 as Bitcoin has become the digital gold standard and is positioning itself as the reserve currency of the world. In 2013, Ethereum established itself as the leader in layer 1 infrastructure, initiating the cycle of growth among web2 and web3 businesses. Since then, over 10,000 tokens have been publicly launched, each with their unique focus.

The growth of each project has a common theme within the technology: Communication. Blockchain infrastructure connects users in ways never before, eliminating a centralized counterparty needed to facilitate that connection, and instead proposes changes to the architecture enabling decentralization as the preferred means of communication. Even though this change has prompted user adoption globally, there remains gaps in the technology that adjust to specific market and cultural conditions in emerging economies.

In developing countries in Latin America, users can’t adopt blockchain settlements where the gas fees are more expensive than the product or service itself, and many users and businesses fail to understand the benefits when building on blockchains abroad. The current transfer of value mechanisms that connect emerging economies to developed economies are overly centralized, slow and costly. It's determined to be why emerging economies in the last 25 years have yet to really “emerge”. These transfer of value networks have failed to improve globalization and local commerce in an efficient way, connecting important economic counterparts in order to create uniformity in how they communicate.

Although economically a very large industry, emerging markets don't just thrive on remittances from users aboard. Their economies are normally derived from production locally. Whether its natural resources and commodities, exports of goods, imports for raw materials for production of those goods, the necessity for a B2B commodity and product based settlement network is clear given that the B2B market is 10x+ the size of consumer remittances with higher average volumes and transactions. Faster fiat settlements, safer FX solutions, and access to international credit terms are only a few of the current pain-points within the market.

KiiChain is unwaveringly committed to delivering high-performance, interconnected, and ultra-secure blockchain solutions as a driver in economic development in emerging markets in an effort to improve communication and globalization. At the heart of our technological prowess is the CometBFT mechanism, a solution for problems that exist in the economy, particularly emerging economies and Latin America. However, more than just a blockchain, Kii Global has built an ecosystem of solutions that include a centralized exchange streamlining institutional liquidity to an array of low cost fiat cash solutions and a robust DeFi mobile app offering an array of low cost custodial and swap solutions.

Step 1: Make sure you have installed the MetaMask or Keplr browser extension.

Step 2: Launch the Explorer App and Connect your Wallet to Testnet Oro.

If you have the MetaMask extension installed in your web browser, it should automatically connect the RPC endpoints.

It will then ask for approval to switch the network from Ethereum (default) to Kiichain Testnet. Click the "Switch Network" button.

Following, it will ask to link with your new wallet address. Click "Next".

Lastly, it will ask for wallet permissions. Click on "Confirm".

Awesome! Your wallet is now connected to the explorer app! Deposit testnet tokens in your address to delegate to the validator.

Step 3: Get testnet tokens.

Kii Global believes in a true non-inflationary environment for Kiichain that does not mint or burn tokens. However, in common PoS blockchains, minting features are popular to be able to cover the staking pool and its rewards.

In order to compensate for this, Kiichain has instituted an "evergreen" model where 5% of the cash flow of Kii Global's overall activity will be diverted to purchase coins in the market to replenish the rewards pool.

This is possible because Kii Global's real world use business model is already functioning, producing positive cash flow as an organization. This feature will be implemented 90 days after launching the token publicly, where earnings from the first 90 days will be sent to the lead market-maker in order to execute the trade and replenish KII into the staking pool.

Explorer App (best option for builders)

Connect your Keplr or MetaMask wallet to the explorer app to stake KII into a validator or to help launch a full node/validator.

Web Wallets

Connect to our web wallet using Keplr or Metamask.

Mobile Wallets

Download and set up our Kii Mobile wallet from the App Store or Google Play. Mobile apps allow users to send and receive KII and stake their KII to a validator of their choice.

KiiChain Testnet Oro

Oro Testnet is the final upgraded testnet before mainnet. Users and builders can interact and build with this testnet's latest features. Oro testnet will also run incentivization programs.

For on-chain activities, activations, airdrops and more, join our open testnet here:

Get a wallet in Testnet

Testnet Oro supports wallet connections with EVM and Cosmos based wallets like MetaMask and Keplr . To set up a wallet, make sure you have the MetaMask or Keplr wallet extension downloaded in your web browser. MetaMask supports extension downloads for the following web browsers: Chrome, Firefox, Brave, Edge and Opera. Kelpr supports wallets in Chrome, Firefox and Edge.

Get Testnet tokens

The command for requesting tokens in our Discord faucet channel is:

$request {address}

Example EVM:

$request Ox12345abcde…

Example Cosmos Address:

$request kii12345abcde…

The full list of commands are:

List commands:

$help

Request tokens:

$request [kii address]

Query an address balance:

$balance [kii address]

Query a transaction:

$tx_info [transaction hash ID]

Query the faucet and node status:

$faucet_status

Query the faucet address:

$faucet_address

How to stake your tokens

Tokens can be staked in the Explorer App by connecting your wallet and delegating to an active validator. Make sure the wallet you have connected to the Explorer App is funded with tokens.

Connect wallet to Explorer App

Developer resources

Quick start links:

Chat with us on Discord

General customer service and developer support are available in our channel. Get to know us.

You can find us on Discord:

How to earn airdrops and rewards

We’re constantly running localized airdrops, hackathons, and competitions in our community.

Follow our X account and stay up to date with all announcements. For additional communities, visit our communities at Galxe, Zealy, TaskOn, and QuestN.

Step 1: Install MetaMask Extension

Step 2: Create your wallet

Once the download has been completed, a prompt will appear, click "Create a new wallet" to begin.

Create a password that will control access to your account via the extension.

Create, record, and properly store your wallet secret phrase. This step is very important as these 12 words are your secret keys to your wallet.

Awesome, nice work! Your wallet has been created. Make sure you store your keys in a safe place!

Step 3: Link your wallet to the KiiChain Testnet.

Wallets like MetaMask and Keplr can be manually connected to various testnets. MetaMask supports EVM-compatible blockchains, and at default, is set to the Ethereum network. You will need to manually connect to the KiiChain network.

The link can be done though multiple sources:

Manually setting the wallet

Click the "Ethereum Mainnet" dropdown bar on the top left and then click "Add Network" on the pop-up box.

Manually add the following testnet chain ID to add the network.

Upon saving and completion, you should be connected to the testnet network!

Download Kii Mobile on the App Store or Google Play

Mobile wallets are currently in deployment mode for Testnet Oro. Mobile wallets are available on the App Store and Google Play for users who would like to have access to the basic functions of the chain. Within the mobile wallet, users can login via email or manage their 24 set word keys.

In the wallet, users can send, receive, and stake their KII by selecting the validator they would like to use to perform all functions. These wallets are currently connected in Testnet and can be used for all developers, hackathons, and competitions.

Mobile wallets will be compatible with Testnet V1 and Testnet Oro.

Testnets

Testnet Oro is our public testnet that is currently active.

Testnet Oro is the permanent testnet with smart contract functionality and EVM compatibility. All Hackathons, Builds, Airdrops, and test deployments should be done on this network. You can find more information such as endpoints, chain data, and general guides here:

Developer Tools

If you are a developer we also have our official SKDs for development:

• Python SDK

Protocols

Kii protocols can be found at these links:

Endpoints

Generally, our chains (testnets and mainnet) follow the same set of endpoints. More information about our endpoints can be found here:

• Endpoints

KiiChain Discord Server

If you would like to connect directly with the community and ask questions related to building on the network, join the discord server where our internal developers are ready to field any questions you have.

KiiChain is a peer-to-peer decentralized EVM-compatible network built with the Cosmos SDK. The public testnet is called KiiChain Testnet Oro.

Testnet Oro is the permanent testnet with smart contract functionality and EVM compatibility. All Hackathons, Builds, Airdrops, and test deployments should be done on this network.

Source code

The source code for the Testnet Oro can be found at:

Endpoints

Testnet Oro has the following endpoints open for development purposes:

Sentry #1:

• GRPC: grpc.uno.sentry.testnet.v3.kiivalidator.com:443

• Peer: 5b6aa55124c0fd28e47d7da091a69973964a9fe1@uno.sentry.testnet.v3.kiivalidator.com:26656

Sentry #2:

• GRPC: grpc.dos.sentry.testnet.v3.kiivalidator.com:443

• Peer: 5e6b283c8879e8d1b0866bda20949f9886aff967@dos.sentry.testnet.v3.kiivalidator.com:26656

Currently, there are no seed nodes or persistent peers available to the public.

Chain information

Here you can find further information about Testnet Oro:

• Chain ID: oro_1336-1

• Total Supply: 1.8b Kii

• Token Denom: akii

• EVM Chain ID: 1336

• Bench32 Prefix: kii

How to chain the network

Instructions on how to join the network can be found at:

Faucet

You can get tokens to our Testnet Oro by using our Explorer app:

Our through our Discord channel:

More information about how to use our discord Faucet can be found at:

Explorer

The testnet Oro also has its own Explorer, it can be found here:

Developer Tools

Endpoints

Rest endpoints for the testnet Oro can be found here:

EVM / CW Addresses

KiiChain Testnet Oro features a mirrored EVM - CW smart contract module that replicates EVM compatibility. CW addresses are structured in Bech32 format with a distinctive "kii" prefix, characteristic of Cosmos-based chains. EVM addresses are structured with the hexadecimal format akin to Ethereum addresses. This alteration reflects a strategic adaptation to streamline interoperability with Ethereum-based tools and infrastructure, facilitating a seamless transition for developers and users alike.

Tokens

KII serves as the primary utility token within the KiiChain ecosystem, facilitating transactions and powering network operations, notably through the payment of gas fees. Distinguished by its fungibility and interoperability, KII can be seamlessly transferred and utilized across various wallet providers, including popular EVM rpc-based options like MetaMask & Coinbase wallet and cosmos-based wallets like Keplr and Leap. By leveraging KII, users can engage in a diverse array of interactions within the KiiChain network, ranging from simple transactions to more complex smart contract executions, thereby driving the adoption and utility of the native token within the broader blockchain landscape.

An overview of developer tools, SDKs and resources for accessing the network.

Note: This project is still under development so future changes will be made.

Overview

This document outlines the detailed implementation plan for the T-REX (Token for Regulated EXchanges) protocol using CosmWasm smart contracts on KiiChain. The T-REX protocol is designed for compliant issuance and management of security tokens on blockchain networks.

Important Links

Contracts and Their Methods

1. CW20 T-REX Token

Extends the CW20 standard with T-REX functionalities and implements permissioned transfers.

Storage

• token_info: TokenInfo

• balances: Map<Addr, Uint128>

• allowances: Map<(Addr, Addr), AllowanceInfo>

• identity_registry: Addr

• compliance: Addr

Execute

• transfer(recipient: Addr, amount: Uint128) -> Result<Response>

  • Description: Transfers tokens to a recipient if they are verified and compliant.

  • Interaction: Calls is_verified on Identity Registry and can_transfer on Modular Compliance.

• transfer_from(owner: Addr, recipient: Addr, amount: Uint128) -> Result<Response>

  • Description: Transfers tokens on behalf of the owner if the recipient is verified and compliant.

  • Interaction: Similar to transfer, but checks allowances first.

Query

• balance(address: Addr) -> BalanceResponse

• token_info() -> TokenInfoResponse

• is_verified_transfer(from: Addr, to: Addr, amount: Uint128) -> IsVerifiedTransferResponse

  • Description: Checks if a transfer would be valid without executing it.

  • Interaction: Calls Identity Registry and Modular Compliance.

2. Identity Registry

Manages investor identities and eligibility.

Storage

• identity_storage: Addr

• trusted_issuers_registry: Addr

• claim_topics_registry: Addr

• agents: Vec

Execute

• register_identity(address: Addr, identity: Addr) -> Result<Response>

  • Description: Registers a new identity for an address.

  • Interaction: Calls Identity Registry Storage to store the mapping.

• update_identity(address: Addr, identity: Addr) -> Result<Response>

  • Description: Updates an existing identity for an address.

• remove_identity(address: Addr) -> Result<Response>

  • Description: Removes an identity for an address.

Query

• is_verified(address: Addr) -> IsVerifiedResponse

  • Description: Checks if an address is verified (has required claims).

  • Interaction: Queries Identity Registry Storage, Trusted Issuers Registry, and Claim Topics Registry.

3. Identity Registry Storage

Stores the mapping of wallet addresses to identity contracts.

Storage

• identities: Map<Addr, Addr>

Execute

• add_identity(address: Addr, identity: Addr) -> Result<Response>

• remove_identity(address: Addr) -> Result<Response>

Query

• get_identity(address: Addr) -> GetIdentityResponse

4. Trusted Issuers Registry

Manages the list of trusted claim issuers.

Storage

• trusted_issuers: Map<Addr, TrustedIssuer>

Execute

• add_trusted_issuer(issuer: Addr, claim_topics: Vec<u32>) -> Result<Response>

• remove_trusted_issuer(issuer: Addr) -> Result<Response>

Query

• is_trusted_issuer(issuer: Addr) -> IsTrustedIssuerResponse

• get_trusted_issuers() -> GetTrustedIssuersResponse

5. Claim Topics Registry

Stores the required claim topics for token eligibility.

Storage

• required_claim_topics: Vec

Execute

• add_claim_topic(topic: u32) -> Result<Response>

• remove_claim_topic(topic: u32) -> Result<Response>

Query

• get_required_claim_topics() -> GetRequiredClaimTopicsResponse

6. Modular Compliance

Implements transfer restriction rules.

Storage

• modules: Vec

• bound_tokens: Vec

Execute

• add_module(module: Addr) -> Result<Response>

• remove_module(module: Addr) -> Result<Response>

• bind_token(token: Addr) -> Result<Response>

Query

• can_transfer(from: Addr, to: Addr, amount: Uint128) -> CanTransferResponse

  • Description: Checks if a transfer complies with all modules.

  • Interaction: Calls check_transfer on each compliance module.

7. ONCHAINID

Represents user identities (similar to ERC-734/735).

Storage

• keys: Map<bytes32, Key>

• claims: Map<bytes32, Claim>

Execute

• add_key(key: bytes32, purpose: u32, key_type: u32) -> Result<Response>

• remove_key(key: bytes32) -> Result<Response>

• add_claim(topic: u32, scheme: u32, issuer: Addr, signature: Vec<u8>, data: Vec<u8>, uri: String) -> Result<Response>

• remove_claim(topic: u32) -> Result<Response>

Query

• get_key(key: bytes32) -> GetKeyResponse

• get_claim(topic: u32) -> GetClaimResponse

8. T-REX Factory

Deploys and configures T-REX token suites.

Storage

• implementation_authority: Addr

• deployed_tokens: Vec

Execute

• deploy_token_suite(token_info: TokenInfo, compliance_info: ComplianceInfo, identity_info: IdentityInfo) -> Result<Response>

  • Description: Deploys a new T-REX token suite.

  • Interaction: Instantiates all necessary contracts and configures them.

Query

• get_deployed_tokens() -> GetDeployedTokensResponse

9. Implementation Authority

Manages contract upgrades and versioning.

Storage

• versions: Map<String, ContractVersion>

• current_version: String

Execute

• add_version(name: String, contracts: Vec<(String, Addr)>) -> Result<Response>

• set_current_version(name: String) -> Result<Response>

Query

• get_current_version() -> GetCurrentVersionResponse

• get_version(name: String) -> GetVersionResponse

Implementation Roadmap

1. Implement CW20 T-REX Token

2. Implement Identity Registry and Identity Registry Storage

3. Implement Trusted Issuers Registry and Claim Topics Registry

4. Implement Modular Compliance

5. Implement ONCHAINID

6. Implement T-REX Factory

7. Implement Implementation Authority

8. Integrate all contracts and perform thorough testing

9. Conduct security audit

10. Deploy to Kii-Chain testnet

11. Final testing and adjustments

12. Deploy to Kii-Chain mainnet

Testing Strategy

• Implement unit tests for each contract function

• Develop integration tests for contract interactions

• Create end-to-end scenarios to test the entire T-REX suite

• Perform fuzz testing to uncover edge cases

• Conduct governance testing to ensure proper access control

Note: This project is still under development so future changes will be made.

Important Links

KiiChain RWA SDK

The RWA (Real World Asset) SDK is a Rust library for interacting with tokenized real-world assets on Cosmos-based blockchains. It provides functionality for token operations, identity management, and compliance handling.

Features

• Token transfers and balance checks

• Identity registration and management

• Compliance module integration

• Blockchain interaction via RPC

Usage Example

This example demonstrates how to initialize the RwaClient, perform a token transfer, and check an account balance. Error handling and proper setup of the signing key are crucial for production use.

For more detailed information on each function and module, please refer to their respective documentation.

What is a Kii validator?

KiiChain is a Cosmos-based blockchain powered by CometBFT that relies on a set of validators to secure the network. The role of validators is to run a full node and participate in consensus by broadcasting votes that contain cryptographic signatures signed by the validator's private key. Validators commit new blocks in the blockchain and receive revenue in exchange for their work. Validators must also participate in governance by voting on proposals. Validators are weighted according to their total stake.

Validator minimum: 10,000 KII

What is a full node?

A full node is a server running a chain's binary (its software) that fully validates transactions and blocks of a blockchain and keeps a full record of all historic activity. A full node is distinct from a pruned node that processes only block headers and a small subset of transactions. Running a full node requires more resources than a pruned node. Validators can decide to run either a full node or a pruned node, but they need to make sure they retain enough blocks to be able to validate new blocks.

Of course, it is possible and encouraged for users to run full nodes even if they do not plan to be validators.

Delegating = Staking

People who cannot or do not want to operate Validators (full nodes) can still participate in the staking process as delegators. Indeed, validators are not chosen based on their self-delegated stake but based on their total stake, which is the sum of their self-delegated stake and of the stake that is delegated to them. This is an important property, as it makes delegators a safeguard against validators who exhibit bad behavior. If a validator misbehaves, their delegators will move their KIIs away from them, thereby reducing their stake. Eventually, if a validator's stake falls under the top 100 addresses with the highest stake, they will exit the validator set.

Delegators share the revenue of their validators, but they also share the risks. In terms of revenue, validators, and delegators differ in that validators can apply a commission on the revenue that goes to their delegator before it is distributed. This commission is known to delegators beforehand and can only change according to predefined constraints (see section below). In terms of risk, delegators' KIIs can be slashed if their validator misbehaves.

To become delegators, KII holders need to send a "Delegate transaction" where they specify how many KIIs they want to bond and to which validator. A list of validator candidates will be displayed in KII Explorer. Later, if a delegator wants to unbond part or all of their stake, they needs to send an "Unbond transaction". From there, the delegator will have to wait 21 days to retrieve their KIIs. Delegators can also send a "Rebond Transaction" to switch from one validator to another, without having to go through the 3-week waiting period.

What is staking?

Kiichain is a public Proof-Of-Stake (PoS) blockchain, meaning that the weight of validators is determined by the amount of staking tokens (KII) bonded as collateral. These KII tokens can be self-delegated directly by the validator or delegated to the validator by other KII holders.

Any user in the system can declare their intention to become a validator by sending a create-validator transaction to become validator candidates.

The weight (i.e. voting power) of a validator determines whether they are an active validator.

Note: This project is still under development so future changes will be made.

Kiijs-SDK

KiiJS is a monorepo that contains multiple NPM libraries for writing applications that interact with KiiChain. Apart from the built SDK, the chain matches a lot of operability from cosmjs.

Documentation

Each package has it's own documentation under its readme file.

Packages

KiiJS consists of smaller NPM packages within the @kiichain namespace. For more detailed documentation on each package, please refer to the table below.

Contributing

All contributions are very welcome! Remember, contribution is not only PRs and code, but any help with docs or helping other developers solve their issues are very appreciated!

Read below to learn how you can take part in the KiiPy project.

Code of Conduct

Contribution Guidelines

Issues, Questions and Discussions

License

kiijs-proto

install

npm install @kiichain/kiijs-proto

Usage

You can utilize the types to build and send messages. To query, you can utilize an RPC query client, while for transactions you will need a wallet client paired with composing a message and then broadcasting it.

RPC Clients

To create an RPC client you can import the following helper and utilize it:

import { kiichain } from '@kiichain/kiijs-proto';

const { createRPCQueryClient } = kiichain.ClientFactory; 
const client = await createRPCQueryClient({ rpcEndpoint: RPC_ENDPOINT });

// now you can query the cosmos modules
const balance = await client.cosmos.bank.v1beta1
    .balance({ address: 'kiichain1addresshere', denom: 'akii' });

Explore the types to find out what types of queries are available and how to utilized them.

Composing Messages

To compose messages, you can utilize the message composer of the respective type you want to build. For instance, tokenfactory messages can be found like this:

import { kiichain } from '@kiichain/kiijs-proto';

const {
    createDenom,
    mint,
    burn,
    changeAdmin,
    setDenomMetadata,
    forceTransfer,
    updateParams
} = kiichain.tokenfactory.v1beta1.MessageComposer.withTypeUrl;

We have a small section with a few more examples.

Cosmos Messages

import { cosmos } from '@kiichain/kiijs-proto';

const {
    fundCommunityPool,
    setWithdrawAddress,
    withdrawDelegatorReward,
    withdrawValidatorCommission
} = cosmos.distribution.v1beta1.MessageComposer.fromPartial;

const {
    multiSend,
    send
} = cosmos.bank.v1beta1.MessageComposer.fromPartial;

const {
    beginRedelegate,
    createValidator,
    delegate,
    editValidator,
    undelegate
} = cosmos.staking.v1beta1.MessageComposer.fromPartial;

const {
    deposit,
    submitProposal,
    vote,
    voteWeighted
} = cosmos.gov.v1beta1.MessageComposer.fromPartial;

Connecting with Wallets and Signing Messages

Initializing the Stargate Client

Use getSigningKiiChainClient to get your SigningStargateClient, with the proto/amino messages full-loaded. No need to manually add amino types, just require and initialize the client:

import { getSigningKiiChainClient } from '@kiichain/kiijs-proto';

const stargateClient = await getSigningKiiChainClient({
  rpcEndpoint,
  signer // OfflineSigner
});

Creating Signers

To broadcast messages, you can create signers with a variety of options:

Amino Signer

Likely you'll want to use the Amino, so unless you need proto, you should use this one:

import { getOfflineSignerAmino as getOfflineSigner } from 'cosmjs-utils';

Proto Signer

import { getOfflineSignerProto as getOfflineSigner } from 'cosmjs-utils';

WARNING: NOT RECOMMENDED TO USE PLAIN-TEXT MNEMONICS. Please take care of your security and use best practices such as AES encryption and/or methods from 12factor applications.

import { chains } from 'chain-registry';

const mnemonic =
  'unfold client turtle either pilot stock floor glow toward bullet car science';
  const chain = chains.find(({ chain_name }) => chain_name === 'kiichain');
  const signer = await getOfflineSigner({
    mnemonic,
    chain
  });

Broadcasting Messages

Now that you have your stargateClient, you can broadcast messages:

import { cosmos } from '@kiichain/kiijs-proto'

const { send } = cosmos.bank.v1beta1.MessageComposer.withTypeUrl;

const msg = send({
    amount: [
    {
        denom: 'akii',
        amount: '10000000000000000'
    }
    ],
    toAddress: address,
    fromAddress: address
});

const fee: StdFee = {
    amount: [
    {
        denom: 'akii',
        amount: '10000000000000000'
    }
    ],
    gas: '86364'
};
const response = await stargateClient.signAndBroadcast(address, [msg], fee);

Converting from Hex to Bech32 and vice-versa

We have a few helper functions for converting Hex to Bech32 and vice versa on the @kiichain/kiijs-evm. We did not import them over here since the proto files are all generated.

import { HexToBech32, Bech32ToHex } from '@kiichain/kiijs-evm'

const kiiAddress = HexToBech32("0xyourhex")

const evmAddress = Bech32ToHex("kiiYouraddress)

Advanced Usage

If you want to manually construct a stargate client

import { OfflineSigner, GeneratedType, Registry } from "@cosmjs/proto-signing";
import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";

import { 
    cosmosAminoConverters,
    cosmosProtoRegistry,
    cosmwasmAminoConverters,
    cosmwasmProtoRegistry,
    ibcProtoRegistry,
    ibcAminoConverters,
    kiichainAminoConverters,
    kiichainProtoRegistry
} from '@kiichain/kiijs-proto';

const signer: OfflineSigner = /* create your signer (see above)  */
const rpcEndpoint = 'https://rpc.dos.sentry.testnet.v3.kiivalidator.com/'; // or another URL

const protoRegistry: ReadonlyArray<[string, GeneratedType]> = [
    ...cosmosProtoRegistry,
    ...cosmwasmProtoRegistry,
    ...ibcProtoRegistry,
    ...kiichainProtoRegistry
];

const aminoConverters = {
    ...cosmosAminoConverters,
    ...cosmwasmAminoConverters,
    ...ibcAminoConverters,
    ...kiichainAminoConverters
};

const registry = new Registry(protoRegistry);
const aminoTypes = new AminoTypes(aminoConverters);

const stargateClient = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
    registry,
    aminoTypes
});

Chain Information

Deploy with Hardhat

1. Install Hardhat

Install the hardhat framework in your project, by typing the following command:

$ npm install --save-dev hardhat

2. Create a hardhat project

After installing Hardhat, create a project. You can create it using typescript or javascript in the following screen:

$ npx hardhat init

888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

Welcome to Hardhat v2.22.8 

? What do you want to do? …
❯ Create a JavaScript project
  Create a TypeScript project
  Create a TypeScript project (with Viem)
  Create an empty hardhat.config.js
  Quit

3. Create a Smart contract and Compile protect

After creating the smart contract in the “Contracts” folder, run the following command to check your code.

$ npx hardhat compile 

5. Set the hardhat configuration file and deploy the smart contract

After creating the ignition deploy file, let's set the blockchain information into the hardhat.config file, with the following information:

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";

const config: HardhatUserConfig = {
  solidity: "0.8.20", // Solidity Version
  networks: {
    kiichain: {
      url: "<https://a.sentry.testnet.kiivalidator.com:8645>",
      chainId: 123454321,
      accounts: [`0x${yourApiKey}`],
    },
  },
};

export default config;

$ npx hardhat ignition deploy ignition/modules/<contractName>.ts --network kiichain

Deploy with Remix

In the Workspace create the file which contains the Smart contract with the .sol extension.

After writing the smart contract, go to the Solidity Compiler section and select your compiler version, is recommended to use the most recent one.

Then press “Compile” button under the Compiler selector.

3. Select your Metamask wallet as Deploy environment

In the “Deploy and Run Transactions” section, move to the Environment and select your Metamask Provider, remember you must be connected to KiiChain Testnet

4. Deploy Smart contract

Select the smart contract to be deployed and write the Constructor parameters is Remix detects them

Finally, you can interact with the different functions in the same section above the Deploy button.

Deploy with Foundry

1. Create a project and installation

Run the following commands in your terminal in order to start the foundry’s installation.

curl -L [<https://foundry.paradigm.xyz>](<https://foundry.paradigm.xyz/>) | bash

then run the following command in another terminal or restart the current one for finishing the installation process.

foundryup

After finishing the foundry’s installation let’s create a new project, run the following commands for starting the new project and then move to it’s folder:

forge init projectName
cd projectName

2. Write and build a contract

Write your smart contract in ‘/src/smartContractName.sol’ and the script in ‘/script/smartContractName.s.sol’, here is an example of that:

This contract will be placed in the path: /src/Counter.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

contract Counter {
    uint256 public number;

    function setNumber(uint256 newNumber) public {
        number = newNumber;
    }

    function increment() public {
        number++;
    }
    
    
    function getCounter() public view returns (uint256) {
        return number;
    }
}

This is the script and will be placed in /script/Counter.s.sol remember to add the .s before the .sol extension.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import {Script, console} from "forge-std/Script.sol";
import {Counter} from "../src/Counter.sol";

contract CounterScript is Script {
    Counter public counter;

    function setUp() public {}

    function run() public {
        vm.startBroadcast();

        counter = new Counter();

        vm.stopBroadcast();
    }
}

then run the following command for build and check that everything is correct.

forge build

3. Deploy

First, you need to run a simulation.

forge script script/Counter.s.sol:CounterScript --fork-url <https://a.sentry.testnet.kiivalidator.com:8645/> --private-key yourPrivateKey

The simulation will be complete after that, and you can run with broadcast.

forge script script/Counter.s.sol:CounterScript --fork-url <https://a.sentry.testnet.kiivalidator.com:8645/> --private-key yourPrivateKey --broadcast

A success message should appear.

Deploy with Thirdweb

In this example, we will create a ERC721 (Non fungible token).

1. Create an account

Storage the API key in a secure place.

2. Create a project

npx thirdweb create

A message appears

Need to install the following packages:
thirdweb@5.46.1
Ok to proceed? (y) y

After the installation this screen should appear, select “Contract”

    $$\\     $$\\       $$\\                 $$\\                         $$\\
    $$ |    $$ |      \\__|                $$ |                        $$ |
  $$$$$$\\   $$$$$$$\\  $$\\  $$$$$$\\   $$$$$$$ |$$\\  $$\\  $$\\  $$$$$$\\  $$$$$$$\\
  \\_$$  _|  $$  __$$\\ $$ |$$  __$$\\ $$  __$$ |$$ | $$ | $$ |$$  __$$\\ $$  __$$\\
    $$ |    $$ |  $$ |$$ |$$ |  \\__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
    $$ |$$\\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
    \\$$$$  |$$ |  $$ |$$ |$$ |      \\$$$$$$$ |\\$$$$$\\$$$$  |\\$$$$$$$\\ $$$$$$$  |
     \\____/ \\__|  \\__|\\__|\\__|       \\_______| \\_____\\____/  \\_______|\\_______/

 💎 thirdweb v0.14.12 💎

? What type of project do you want to create? » - Use arrow-keys. Return to submit.
    App
>   Contract
    Dynamic Contract Extension

Select the following options:

√ What type of project do you want to create? » Contract
√ What is your project named? ... ERC721-Example
√ What framework do you want to use? » Forge
√ What will be the name of your new smart contract? ... MyContract
√ What type of contract do you want to start from? » ERC721
√ What extensions do you want to add to your contract? » None

3. Write a smart contract and deploy

Enter the directory and run the following command:

cd erc721-example
npx thirdweb deploy -k yourApiKey

Open the link and fill in the fields.

In chain choose

add Custom Network

Finally, select Deploy Now and accept the transaction in your wallet.

Confirming Smart Contract on Explorer App

Introduction

In this tutorial, you will learn how to create a simple decentralized application (dApp) built on KiiChain. We will use tools such as React, TypeScript, and Ethers.js to build a basic wallet management system.

Project setup

Tools

We will be using the following tools:

• npx for managing Node.js packages and running commands.

• ethers for interacting with the Ethereum blockchain and other compatible chains like KiiChain.

• React for building the user interface.

• TypeScript for adding static types to JavaScript.

Create project

First, navigate to your working directory, open a terminal, and run the following commands to create a new React project with TypeScript:

npx create-react-app kii-dapp --template typescript
cd kii-dapp

After the project is set up, open the code in your preferred editor. If you are using Visual Studio Code, you can do this with:

code .

You should now see the following project structure:

Install dependencies

Next, you need to install the ethers library. Run the following command in the terminal within your project directory:

npm i ethers

Coding the dApp

Create the Repository

Create a new file at src/repository/kiichain.repository.ts. The directory needs to be created.

import { ethers } from 'ethers';

export function getProvider(): ethers.JsonRpcProvider {
    const url = "<https://a.sentry.testnet.kiivalidator.com:8645/>";
    const provider = new ethers.JsonRpcProvider(url, {
        chainId: 123454321,
        name: "kiichaind",
    });
    return provider;
}

export function getSigner(
    wallet: ethers.Wallet,
    provider: ethers.JsonRpcProvider
): ethers.Wallet {
    return wallet.connect(provider);
}

export function createWallet(
    provider: ethers.JsonRpcProvider
): ethers.HDNodeWallet {
    return ethers.Wallet.createRandom(provider);
}

export function getWalletFromPhrase(
    Phrase: string,
    provider: ethers.JsonRpcProvider
): ethers.HDNodeWallet {
    return ethers.Wallet.fromPhrase(Phrase!).connect(provider);
}

This repository file contains functions for basic operations like creating a wallet, connecting to a wallet using a seed phrase, and getting the balance of a wallet.

What is a Signer and a Provider?

In decentralized application (dApp) development, especially when interacting with blockchains like KiiChain, it's essential to understand the concepts of Provider and Signer. These components play crucial roles in communicating with and managing transactions on the blockchain.

Provider

A Provider is a component that allows your dApp to connect to and interact with the blockchain. It provides methods to read data from the blockchain, such as transaction statuses, account balances, and other network details. The provider does not have access to private keys and therefore cannot sign transactions.

Signer

A Signer is a component that represents an entity capable of making transactions on the blockchain, meaning it can sign them. A signer has access to the private keys necessary to authorize and send transactions, allowing you to modify the blockchain state, such as transferring tokens or interacting with smart contracts.

Create the Wallet Manager Component

Create a new file at src/components/WalletManager.tsx . The directory needs to be created

import React, { useEffect, useState } from 'react';
import { ethers } from 'ethers';
import { createWallet, getProvider, getWalletFromPhrase } from '../repository/kiichain.repository';

const WalletManager: React.FC = () => {
    const [wallet, setWallet] = useState<ethers.HDNodeWallet | null>(null);
    const [balance, setBalance] = useState<string | null>(null);
    const [mnemonic, setMnemonic] = useState<string>(''); // Estado para la seed phrase

    const provider = getProvider();

    // Handle wallet creation
    const handleCreateWallet = (): void => {
        const newWallet = createWallet(provider);
        setWallet(newWallet);
        console.log('New Wallet Address:', newWallet.address);
        console.log('Seed Phrase:', newWallet.mnemonic?.phrase);
    };

    // Handle connecting to a wallet via a mnemonic phrase
    const handleConnectWallet = (): void => {
        if (!mnemonic) {
            console.error('Mnemonic is empty');
            return;
        }
        const existingWallet = getWalletFromPhrase(mnemonic, provider);
        setWallet(existingWallet);
        console.log('Connected Wallet Address:', existingWallet.address);
    };

    // Fetch and display wallet balance
    const handleGetBalance = async (): Promise<void> => {
        if (wallet) {
            const balance: bigint = await provider.getBalance(wallet.address);
            setBalance(ethers.formatEther(balance));
        } else {
            console.error('No wallet connected');
        }
    };

    useEffect(() => {
        if (wallet) {
            handleGetBalance();
        }
    }, [wallet]);
    return (
        <div>
            <h1>Kiichain Wallet Manager</h1>
            <button onClick={handleCreateWallet}>Create New Wallet</button>

            <div>
                <input
                    type="password"
                    value={mnemonic}
                    onChange={(e) => setMnemonic(e.target.value)}
                    placeholder="Enter your seed phrase"
                />
                <button onClick={handleConnectWallet}>Connect Wallet via Seed Phrase</button>
            </div>

            {wallet && <p>Wallet Address: {wallet.address}</p>}
            {balance && <p>Wallet Balance: {balance} Kii</p>}
        </div>
    );
};

export default WalletManager;

This component implements the functions from the repository and displays the relevant information, such as the wallet address and balance.

Run the dApp

To check if everything is working correctly, you need to run the project. Open your terminal in the project directory and execute the following command:

npm run start

If everything is set up properly, your application should start, and the following screen will appear:

Testing the Wallet Functionality

1. Create a New Wallet: Click the "Create New Wallet" button. A new wallet will be generated, and the address along with the seed phrase will be displayed in the console.

2. Access the Developer Console:

   • Right-click anywhere on the page and select "Inspect" to open the Developer Tools.

   • Navigate to the "Console" tab to see the output.

3. Connect to the Wallet: Copy the seed phrase from the console, paste it into the input field under "Enter your seed phrase," and click "Connect Wallet via Seed Phrase."

4. View Wallet Balance: If connected successfully, the wallet's balance should be displayed on the screen.

By following these steps, you can confirm that the dApp is functioning as expected.

Deploying the dApp Using Firebase

To deploy your decentralized application (dApp) using Firebase Hosting, follow these steps:

Step 1: Set Up a Firebase Project

1. Create a Project in Firebase:

   • Click on "Create a project".

   • Name your project and disable Google Analytics (optional for this tutorial).

   • Click "Continue" once the project is ready.
2. Access Firebase Hosting:

   • In the left menu, go to Build → Hosting.

   • Click "Get started" to begin setting up Firebase Hosting.

Step 2: Initialize Firebase Hosting

1. Install Firebase CLI:

   • Open your terminal and install Firebase CLI globally

     Copy

     npm install -g firebase-tools

2. Login and Initialize Firebase:

   • Inside your project directory, run

     Copy

     firebase login
     firebase init

   • During initialization, select the following options:

     • Features: Hosting: Configure files for Firebase Hosting

     • Project Setup: Use an existing project

     • Public Directory: ‘build’

     • Single-page App: No

     • Automatic Builds/Deploys: No

   Copy

   ? Are you ready to proceed? Yes
   ? Which Firebase features do you want to set up for this directory? Press Space to select features, then Enter to confirm your choices. Hosting: Configure files  
   for Firebase Hosting and (optionally) set up GitHub Action deploys
   
   === Project Setup
   
   First, let's associate this project directory with a Firebase project.
   You can create multiple project aliases by running firebase use --add,
   but for now we'll just set up a default project.
   
   ? Please select an option: Use an existing project
   ? Select a default Firebase project for this directory: kii-dapp-test (kii-dapp-test)
   i  Using project kii-dapp-test (kii-dapp-test)
   
   === Hosting Setup
   
   Your public directory is the folder (relative to your project directory) that
   will contain Hosting assets to be uploaded with firebase deploy. If you
   have a build process for your assets, use your build's output directory.
   
   ? What do you want to use as your public directory? build
   ? Configure as a single-page app (rewrite all urls to /index.html)? No
   ? Set up automatic builds and deploys with GitHub? No
   +  Wrote build/404.html
   +  Wrote build/index.html
   
   i  Writing configuration info to firebase.json...
   i  Writing project information to .firebaserc...
   
   +  Firebase initialization complete!

Step 3: Build and Deploy Your dApp

1. Build the project:

   • Run the following command to generate the production-ready files

     Copy

     npm run build

2. Deploy to Firebase

   • Deploy your built project to Firebase Hosting

     Copy

     firebase deploy

     Copy

     === Deploying to 'kii-dapp-test'...
     
     i  deploying hosting
     i  hosting[kii-dapp-test]: beginning deploy...
     i  hosting[kii-dapp-test]: found 14 files in build
     +  hosting[kii-dapp-test]: file upload complete
     i  hosting[kii-dapp-test]: finalizing version...
     +  hosting[kii-dapp-test]: version finalized
     i  hosting[kii-dapp-test]: releasing new version...
     +  hosting[kii-dapp-test]: release complete
     
     +  Deploy complete!
     
     Project Console: <https://console.firebase.google.com/project/kii-dapp-test/overview>
     Hosting URL: <https://kii-dapp-test.web.app>

Once the deployment is complete, the URL of your live dApp will be shown in the terminal.

@kiichain/kiijs-evm

Installation

yarn add @kiichain/kiijs-evm ethers viem

Wallet Connection

This package provides exports for easily interacting with viem, and ethers.js. You can interact with the KiiChain EVM using all the same hooks and helper functions these tools offer. Read the viem and ethers v6 documentation for more information on how to use these tools.

Wallet network setup

Ensure that your EVM wallet has the KiiChain network enabled.

Connection with ethers v6

The 'ethers' package is a popular library for interacting with the Ethereum blockchain. This package provides a helper function for creating an ethers provider that is connected to the KiiChain EVM.

import { getBankPrecompileEthersV6Contract } from '@kiichain/kiijs-evm';
import { ethers } from 'ethers';

const provider = new ethers.BrowserProvider(window.ethereum); // or any other provider
const signer = await provider.getSigner();

const accounts = await provider.send('eth_requestAccounts', []);

const contract = getBankPrecompileEthersV6Contract(signer);

const cosmosAddress = await contract.balances("yourAddress");

An alternative without the popup is to directly use your private key to connect.

import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://json-rpc.dos.sentry.testnet.v3.kiivalidator.com/');
const wallet = new ethers.Wallet("0xyourprivatekey", provider);

Usage with viem

This package exports viem Chains and precompile ABI's for KiiChain. The ABI used in the ethers example above is a viem ABI instance and the ARCTIC_1_VIEM_CHAIN is a viem Chain instance.

Interoperability with Cosmos

KiiChain v3 supports both EVM JSON-RPC and Cosmos RPC interfaces. In order to easily interact with certain Cosmos modules, KiiChain v3 has a set of precompiled contracts that can be called from the EVM.

Interoperability using Wagmi, viem, and ethers

Each precompile has contract exports a typed 'ethers' contracts and provides the ABI and contract addresses for each precompile for usage with Wagmi and viem.

Bank Precompile

The Bank precompile contract provides functionalities for managing balances, supply, symbols, and more.

Functions

Precompile Addresses

0x000000000000000000000000000000000000080

Bech32 Precompile

The bech32 precompile contract provides ways to turn a hex address to bech32 and vice-versa. There is also functions in the library under the precompile to do the same without using the contract.

import { HexToBech32, Bech32ToHex } from '@kiichain/kiijs-evm'

const kiiAddress = HexToBech32("0xyourhex")

const evmAddress = Bech32ToHex("kiiYouraddress)

Distribution Precompile

The Distribution precompile contract facilitates operations related to rewards withdrawal and distribution.

Functions

Here's the table representation of your Distribution ABI:

Precompile Addresses

0x0000000000000000000000000000000000000801

Evidence Precompile

The Evidence precompile contract provides functionalities for dealing with evidences.

Functions

Precompile Addresses

0x0000000000000000000000000000000000000807

Governance Precompile

The Governance precompile contract supports actions to deposit funds into proposals, view them and interact with them.

Functions

Precompile Addresses

0x0000000000000000000000000000000000000805

ICS20 Precompile

Enables cross-chain token transfers via IBC with granular permission control over channels and denominations.

Functions